1 using System;
2 using System.Collections;
3 using System.Text.Parsing;
4
5
6
7 namespace cmsx.intermediate
8 {
9 public class IntermediateCodeFileGrammar : System.Text.Parsing.Grammar
10 {
11 public IntermediateCodeFileGrammar() : this(new ParsingDomain())
12 {
13 }
14 public IntermediateCodeFileGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("IntermediateCodeFileGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cmsx.intermediate")), parsingDomain)
15 {
16 SetOwner(0);
17 keywords0.Add(ToUtf32("void"));
18 keywords0.Add(ToUtf32("byte"));
19 keywords0.Add(ToUtf32("float"));
20 keywords0.Add(ToUtf32("uint"));
21 keywords0.Add(ToUtf32("bool"));
22 keywords0.Add(ToUtf32("long"));
23 keywords0.Add(ToUtf32("ushort"));
24 keywords0.Add(ToUtf32("ulong"));
25 keywords0.Add(ToUtf32("double"));
26 keywords0.Add(ToUtf32("int"));
27 keywords0.Add(ToUtf32("sbyte"));
28 keywords0.Add(ToUtf32("short"));
29 RegisterParsingDomain(parsingDomain);
30 parsingDomain->AddGrammar(this);
31 CreateRules();
32 Link();
33 }
34 public void Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, cmsx.intermediate.Context* context)
35 {
36 Scanner scanner(start, end, fileName, fileIndex, SkipRule());
37 UniquePtr<XmlLog> xmlLog;
38 if (Log() != null)
39 {
40 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
41 scanner.SetLog(xmlLog.Get());
42 xmlLog->WriteBeginRule( u"parse");
43 xmlLog->IncIndent();
44 }
45 Stack<UniquePtr<Object>> stack;
46 UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
47 scanner.SetParsingData(parsingData.Get());
48 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context)));
49 Match match = base->Parse(scanner, stack, parsingData.Get());
50 Span stop = scanner.GetSpan();
51 if (Log() != null)
52 {
53 xmlLog->DecIndent();
54 xmlLog->WriteEndRule( u"parse");
55 }
56 if (!match.Hit() || stop.start != cast<int>(end - start))
57 {
58 if (StartRule() != null)
59 {
60 throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
61 }
62 else
63 {
64 throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
65 }
66 }
67 }
68
69 public class IntermediateCodeFileRule : System.Text.Parsing.RuleParser
70 {
71 public IntermediateCodeFileRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
72 {
73 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
74 }
75 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
76 {
77 parsingData->PushContext(Id(), new Context());
78 Context* context = cast<Context*>(parsingData->GetContext(Id()));
79 UniquePtr<Object> context_value = stack.Pop();
80 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
81 }
82 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
83 {
84 parsingData->PopContext(Id());
85 }
86 public override void Link()
87 {
88 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
89 a0ActionParser->SetAction(A0Action);
90 NonterminalParser* typeDeclarationsNonterminalParser = GetNonterminal(ToUtf32("TypeDeclarations"));
91 typeDeclarationsNonterminalParser->SetPre(PreTypeDeclarations);
92 NonterminalParser* functionsNonterminalParser = GetNonterminal(ToUtf32("Functions"));
93 functionsNonterminalParser->SetPre(PreFunctions);
94 }
95 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
96 {
97 Context* context = cast<Context*>(parsingData->GetContext(Id()));
98 context->context->SetFileName(fileName);
99 }
100 public void PreTypeDeclarations(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
101 {
102 Context* context = cast<Context*>(parsingData->GetContext(Id()));
103 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
104 }
105 public void PreFunctions(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
106 {
107 Context* context = cast<Context*>(parsingData->GetContext(Id()));
108 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
109 }
110 public class Context : System.Text.Parsing.Context
111 {
112 public Context() : context()
113 {
114 }
115 public cmsx.intermediate.Context* context;
116 }
117 }
118
119 public class TypeDeclarationsRule : System.Text.Parsing.RuleParser
120 {
121 public TypeDeclarationsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
122 {
123 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
124 }
125 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
126 {
127 parsingData->PushContext(Id(), new Context());
128 Context* context = cast<Context*>(parsingData->GetContext(Id()));
129 UniquePtr<Object> context_value = stack.Pop();
130 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
131 }
132 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
133 {
134 parsingData->PopContext(Id());
135 }
136 public override void Link()
137 {
138 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
139 a0ActionParser->SetAction(A0Action);
140 NonterminalParser* typeDeclarationNonterminalParser = GetNonterminal(ToUtf32("TypeDeclaration"));
141 typeDeclarationNonterminalParser->SetPre(PreTypeDeclaration);
142 }
143 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
144 {
145 Context* context = cast<Context*>(parsingData->GetContext(Id()));
146 context->context->ResolveTypes();
147 }
148 public void PreTypeDeclaration(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
149 {
150 Context* context = cast<Context*>(parsingData->GetContext(Id()));
151 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
152 }
153 public class Context : System.Text.Parsing.Context
154 {
155 public Context() : context()
156 {
157 }
158 public cmsx.intermediate.Context* context;
159 }
160 }
161
162 public class DataDefinitionsRule : System.Text.Parsing.RuleParser
163 {
164 public DataDefinitionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
165 {
166 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
167 }
168 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
169 {
170 parsingData->PushContext(Id(), new Context());
171 Context* context = cast<Context*>(parsingData->GetContext(Id()));
172 UniquePtr<Object> context_value = stack.Pop();
173 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
174 }
175 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
176 {
177 parsingData->PopContext(Id());
178 }
179 public override void Link()
180 {
181 NonterminalParser* dataDefinitionNonterminalParser = GetNonterminal(ToUtf32("DataDefinition"));
182 dataDefinitionNonterminalParser->SetPre(PreDataDefinition);
183 }
184 public void PreDataDefinition(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
185 {
186 Context* context = cast<Context*>(parsingData->GetContext(Id()));
187 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
188 }
189 public class Context : System.Text.Parsing.Context
190 {
191 public Context() : context()
192 {
193 }
194 public cmsx.intermediate.Context* context;
195 }
196 }
197
198 public class FunctionsRule : System.Text.Parsing.RuleParser
199 {
200 public FunctionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
201 {
202 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
203 }
204 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
205 {
206 parsingData->PushContext(Id(), new Context());
207 Context* context = cast<Context*>(parsingData->GetContext(Id()));
208 UniquePtr<Object> context_value = stack.Pop();
209 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
210 }
211 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
212 {
213 parsingData->PopContext(Id());
214 }
215 public override void Link()
216 {
217 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("Function"));
218 functionNonterminalParser->SetPre(PreFunction);
219 }
220 public void PreFunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
221 {
222 Context* context = cast<Context*>(parsingData->GetContext(Id()));
223 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
224 }
225 public class Context : System.Text.Parsing.Context
226 {
227 public Context() : context()
228 {
229 }
230 public cmsx.intermediate.Context* context;
231 }
232 }
233
234 public class FunctionRule : System.Text.Parsing.RuleParser
235 {
236 public FunctionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
237 {
238 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
239 }
240 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
241 {
242 parsingData->PushContext(Id(), new Context());
243 Context* context = cast<Context*>(parsingData->GetContext(Id()));
244 UniquePtr<Object> context_value = stack.Pop();
245 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
246 }
247 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
248 {
249 parsingData->PopContext(Id());
250 }
251 public override void Link()
252 {
253 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
254 a0ActionParser->SetAction(A0Action);
255 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("function"));
256 functionNonterminalParser->SetPre(Prefunction);
257 functionNonterminalParser->SetPost(Postfunction);
258 NonterminalParser* basicBlockNonterminalParser = GetNonterminal(ToUtf32("BasicBlock"));
259 basicBlockNonterminalParser->SetPre(PreBasicBlock);
260 }
261 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
262 {
263 Context* context = cast<Context*>(parsingData->GetContext(Id()));
264 context->context->SetCurrentFunction(context->fromfunction);
265 }
266 public void Prefunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
267 {
268 Context* context = cast<Context*>(parsingData->GetContext(Id()));
269 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
270 }
271 public void Postfunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
272 {
273 Context* context = cast<Context*>(parsingData->GetContext(Id()));
274 if (matched)
275 {
276 UniquePtr<Object> fromfunction_value = stack.Pop();
277 context->fromfunction = *cast<ValueObject<Function*>*>(fromfunction_value.Get());
278 }
279 }
280 public void PreBasicBlock(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
281 {
282 Context* context = cast<Context*>(parsingData->GetContext(Id()));
283 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
284 stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->fromfunction)));
285 }
286 public class Context : System.Text.Parsing.Context
287 {
288 public Context() : context(), fromfunction()
289 {
290 }
291 public cmsx.intermediate.Context* context;
292 public Function* fromfunction;
293 }
294 }
295
296 public class FunctionHeaderRule : System.Text.Parsing.RuleParser
297 {
298 public FunctionHeaderRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
299 {
300 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
301 SetValueTypeName(ToUtf32("Function*"));
302 }
303 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
304 {
305 parsingData->PushContext(Id(), new Context());
306 Context* context = cast<Context*>(parsingData->GetContext(Id()));
307 UniquePtr<Object> context_value = stack.Pop();
308 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
309 }
310 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
311 {
312 Context* context = cast<Context*>(parsingData->GetContext(Id()));
313 if (matched)
314 {
315 stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->value)));
316 }
317 parsingData->PopContext(Id());
318 }
319 public override void Link()
320 {
321 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
322 a0ActionParser->SetAction(A0Action);
323 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
324 functionTypeNonterminalParser->SetPre(PrefunctionType);
325 functionTypeNonterminalParser->SetPost(PostfunctionType);
326 NonterminalParser* functionIdNonterminalParser = GetNonterminal(ToUtf32("functionId"));
327 functionIdNonterminalParser->SetPost(PostfunctionId);
328 }
329 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
330 {
331 Context* context = cast<Context*>(parsingData->GetContext(Id()));
332 context->value = context->context->AddFunction(span.lineNumber, context->fromfunctionType, ToUtf8(context->fromfunctionId));
333 }
334 public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
335 {
336 Context* context = cast<Context*>(parsingData->GetContext(Id()));
337 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
338 }
339 public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
340 {
341 Context* context = cast<Context*>(parsingData->GetContext(Id()));
342 if (matched)
343 {
344 UniquePtr<Object> fromfunctionType_value = stack.Pop();
345 context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
346 }
347 }
348 public void PostfunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
349 {
350 Context* context = cast<Context*>(parsingData->GetContext(Id()));
351 if (matched)
352 {
353 UniquePtr<Object> fromfunctionId_value = stack.Pop();
354 context->fromfunctionId = *cast<ValueObject<ustring>*>(fromfunctionId_value.Get());
355 }
356 }
357 public class Context : System.Text.Parsing.Context
358 {
359 public Context() : context(), value(), fromfunctionType(), fromfunctionId()
360 {
361 }
362 public cmsx.intermediate.Context* context;
363 public Function* value;
364 public Type* fromfunctionType;
365 public ustring fromfunctionId;
366 }
367 }
368
369 public class BasicBlockRule : System.Text.Parsing.RuleParser
370 {
371 public BasicBlockRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
372 {
373 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
374 AddInheritedAttribute(AttrOrVar(ToUtf32("Function*"), ToUtf32("function")));
375 AddLocalVariable(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
376 }
377 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
378 {
379 parsingData->PushContext(Id(), new Context());
380 Context* context = cast<Context*>(parsingData->GetContext(Id()));
381 UniquePtr<Object> function_value = stack.Pop();
382 context->function = *cast<ValueObject<Function*>*>(function_value.Get());
383 UniquePtr<Object> context_value = stack.Pop();
384 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
385 }
386 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
387 {
388 parsingData->PopContext(Id());
389 }
390 public override void Link()
391 {
392 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
393 a0ActionParser->SetAction(A0Action);
394 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
395 idNonterminalParser->SetPost(Postid);
396 NonterminalParser* instructionLineNonterminalParser = GetNonterminal(ToUtf32("InstructionLine"));
397 instructionLineNonterminalParser->SetPre(PreInstructionLine);
398 }
399 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
400 {
401 Context* context = cast<Context*>(parsingData->GetContext(Id()));
402 context->bb = context->function->AddBasicBlock(context->fromid);
403 }
404 public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
405 {
406 Context* context = cast<Context*>(parsingData->GetContext(Id()));
407 if (matched)
408 {
409 UniquePtr<Object> fromid_value = stack.Pop();
410 context->fromid = *cast<ValueObject<uint>*>(fromid_value.Get());
411 }
412 }
413 public void PreInstructionLine(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
414 {
415 Context* context = cast<Context*>(parsingData->GetContext(Id()));
416 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
417 stack.Push(UniquePtr<Object>(new ValueObject<BasicBlock*>(context->bb)));
418 }
419 public class Context : System.Text.Parsing.Context
420 {
421 public Context() : context(), function(), bb(), fromid()
422 {
423 }
424 public cmsx.intermediate.Context* context;
425 public Function* function;
426 public BasicBlock* bb;
427 public uint fromid;
428 }
429 }
430
431 public class InstructionLineRule : System.Text.Parsing.RuleParser
432 {
433 public InstructionLineRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
434 {
435 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
436 AddInheritedAttribute(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
437 }
438 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
439 {
440 parsingData->PushContext(Id(), new Context());
441 Context* context = cast<Context*>(parsingData->GetContext(Id()));
442 UniquePtr<Object> bb_value = stack.Pop();
443 context->bb = *cast<ValueObject<BasicBlock*>*>(bb_value.Get());
444 UniquePtr<Object> context_value = stack.Pop();
445 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
446 }
447 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
448 {
449 parsingData->PopContext(Id());
450 }
451 public override void Link()
452 {
453 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
454 a0ActionParser->SetAction(A0Action);
455 NonterminalParser* instructionNonterminalParser = GetNonterminal(ToUtf32("Instruction"));
456 instructionNonterminalParser->SetPre(PreInstruction);
457 instructionNonterminalParser->SetPost(PostInstruction);
458 }
459 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
460 {
461 Context* context = cast<Context*>(parsingData->GetContext(Id()));
462 context->bb->AddInstruction(context->fromInstruction);
463 }
464 public void PreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
465 {
466 Context* context = cast<Context*>(parsingData->GetContext(Id()));
467 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
468 }
469 public void PostInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
470 {
471 Context* context = cast<Context*>(parsingData->GetContext(Id()));
472 if (matched)
473 {
474 UniquePtr<Object> fromInstruction_value = stack.Pop();
475 context->fromInstruction = *cast<ValueObject<Instruction*>*>(fromInstruction_value.Get());
476 }
477 }
478 public class Context : System.Text.Parsing.Context
479 {
480 public Context() : context(), bb(), fromInstruction()
481 {
482 }
483 public cmsx.intermediate.Context* context;
484 public BasicBlock* bb;
485 public Instruction* fromInstruction;
486 }
487 }
488
489 public class InstructionRule : System.Text.Parsing.RuleParser
490 {
491 public InstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
492 {
493 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
494 SetValueTypeName(ToUtf32("Instruction*"));
495 }
496 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
497 {
498 parsingData->PushContext(Id(), new Context());
499 Context* context = cast<Context*>(parsingData->GetContext(Id()));
500 UniquePtr<Object> context_value = stack.Pop();
501 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
502 }
503 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
504 {
505 Context* context = cast<Context*>(parsingData->GetContext(Id()));
506 if (matched)
507 {
508 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
509 }
510 parsingData->PopContext(Id());
511 }
512 public override void Link()
513 {
514 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
515 a0ActionParser->SetAction(A0Action);
516 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
517 a1ActionParser->SetAction(A1Action);
518 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
519 a2ActionParser->SetAction(A2Action);
520 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
521 a3ActionParser->SetAction(A3Action);
522 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
523 a4ActionParser->SetAction(A4Action);
524 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
525 a5ActionParser->SetAction(A5Action);
526 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
527 a6ActionParser->SetAction(A6Action);
528 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
529 a7ActionParser->SetAction(A7Action);
530 NonterminalParser* storeInstructionNonterminalParser = GetNonterminal(ToUtf32("StoreInstruction"));
531 storeInstructionNonterminalParser->SetPre(PreStoreInstruction);
532 storeInstructionNonterminalParser->SetPost(PostStoreInstruction);
533 NonterminalParser* argInstructionNonterminalParser = GetNonterminal(ToUtf32("ArgInstruction"));
534 argInstructionNonterminalParser->SetPre(PreArgInstruction);
535 argInstructionNonterminalParser->SetPost(PostArgInstruction);
536 NonterminalParser* jumpInstructionNonterminalParser = GetNonterminal(ToUtf32("JumpInstruction"));
537 jumpInstructionNonterminalParser->SetPre(PreJumpInstruction);
538 jumpInstructionNonterminalParser->SetPost(PostJumpInstruction);
539 NonterminalParser* branchInstructionNonterminalParser = GetNonterminal(ToUtf32("BranchInstruction"));
540 branchInstructionNonterminalParser->SetPre(PreBranchInstruction);
541 branchInstructionNonterminalParser->SetPost(PostBranchInstruction);
542 NonterminalParser* procedureCallInstructionNonterminalParser = GetNonterminal(ToUtf32("ProcedureCallInstruction"));
543 procedureCallInstructionNonterminalParser->SetPre(PreProcedureCallInstruction);
544 procedureCallInstructionNonterminalParser->SetPost(PostProcedureCallInstruction);
545 NonterminalParser* retInstructionNonterminalParser = GetNonterminal(ToUtf32("RetInstruction"));
546 retInstructionNonterminalParser->SetPre(PreRetInstruction);
547 retInstructionNonterminalParser->SetPost(PostRetInstruction);
548 NonterminalParser* switchInstructionNonterminalParser = GetNonterminal(ToUtf32("SwitchInstruction"));
549 switchInstructionNonterminalParser->SetPre(PreSwitchInstruction);
550 switchInstructionNonterminalParser->SetPost(PostSwitchInstruction);
551 NonterminalParser* valueInstructionNonterminalParser = GetNonterminal(ToUtf32("ValueInstruction"));
552 valueInstructionNonterminalParser->SetPre(PreValueInstruction);
553 valueInstructionNonterminalParser->SetPost(PostValueInstruction);
554 }
555 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
556 {
557 Context* context = cast<Context*>(parsingData->GetContext(Id()));
558 context->value = context->fromStoreInstruction;
559 }
560 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
561 {
562 Context* context = cast<Context*>(parsingData->GetContext(Id()));
563 context->value = context->fromArgInstruction;
564 }
565 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
566 {
567 Context* context = cast<Context*>(parsingData->GetContext(Id()));
568 context->value = context->fromJumpInstruction;
569 }
570 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
571 {
572 Context* context = cast<Context*>(parsingData->GetContext(Id()));
573 context->value = context->fromBranchInstruction;
574 }
575 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
576 {
577 Context* context = cast<Context*>(parsingData->GetContext(Id()));
578 context->value = context->fromProcedureCallInstruction;
579 }
580 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
581 {
582 Context* context = cast<Context*>(parsingData->GetContext(Id()));
583 context->value = context->fromRetInstruction;
584 }
585 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
586 {
587 Context* context = cast<Context*>(parsingData->GetContext(Id()));
588 context->value = context->fromSwitchInstruction;
589 }
590 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
591 {
592 Context* context = cast<Context*>(parsingData->GetContext(Id()));
593 context->value = context->fromValueInstruction;
594 }
595 public void PreStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
596 {
597 Context* context = cast<Context*>(parsingData->GetContext(Id()));
598 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
599 }
600 public void PostStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
601 {
602 Context* context = cast<Context*>(parsingData->GetContext(Id()));
603 if (matched)
604 {
605 UniquePtr<Object> fromStoreInstruction_value = stack.Pop();
606 context->fromStoreInstruction = *cast<ValueObject<Instruction*>*>(fromStoreInstruction_value.Get());
607 }
608 }
609 public void PreArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
610 {
611 Context* context = cast<Context*>(parsingData->GetContext(Id()));
612 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
613 }
614 public void PostArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
615 {
616 Context* context = cast<Context*>(parsingData->GetContext(Id()));
617 if (matched)
618 {
619 UniquePtr<Object> fromArgInstruction_value = stack.Pop();
620 context->fromArgInstruction = *cast<ValueObject<Instruction*>*>(fromArgInstruction_value.Get());
621 }
622 }
623 public void PreJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
624 {
625 Context* context = cast<Context*>(parsingData->GetContext(Id()));
626 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
627 }
628 public void PostJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
629 {
630 Context* context = cast<Context*>(parsingData->GetContext(Id()));
631 if (matched)
632 {
633 UniquePtr<Object> fromJumpInstruction_value = stack.Pop();
634 context->fromJumpInstruction = *cast<ValueObject<Instruction*>*>(fromJumpInstruction_value.Get());
635 }
636 }
637 public void PreBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
638 {
639 Context* context = cast<Context*>(parsingData->GetContext(Id()));
640 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
641 }
642 public void PostBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
643 {
644 Context* context = cast<Context*>(parsingData->GetContext(Id()));
645 if (matched)
646 {
647 UniquePtr<Object> fromBranchInstruction_value = stack.Pop();
648 context->fromBranchInstruction = *cast<ValueObject<Instruction*>*>(fromBranchInstruction_value.Get());
649 }
650 }
651 public void PreProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
652 {
653 Context* context = cast<Context*>(parsingData->GetContext(Id()));
654 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
655 }
656 public void PostProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
657 {
658 Context* context = cast<Context*>(parsingData->GetContext(Id()));
659 if (matched)
660 {
661 UniquePtr<Object> fromProcedureCallInstruction_value = stack.Pop();
662 context->fromProcedureCallInstruction = *cast<ValueObject<Instruction*>*>(fromProcedureCallInstruction_value.Get());
663 }
664 }
665 public void PreRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
666 {
667 Context* context = cast<Context*>(parsingData->GetContext(Id()));
668 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
669 }
670 public void PostRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
671 {
672 Context* context = cast<Context*>(parsingData->GetContext(Id()));
673 if (matched)
674 {
675 UniquePtr<Object> fromRetInstruction_value = stack.Pop();
676 context->fromRetInstruction = *cast<ValueObject<Instruction*>*>(fromRetInstruction_value.Get());
677 }
678 }
679 public void PreSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
680 {
681 Context* context = cast<Context*>(parsingData->GetContext(Id()));
682 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
683 }
684 public void PostSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
685 {
686 Context* context = cast<Context*>(parsingData->GetContext(Id()));
687 if (matched)
688 {
689 UniquePtr<Object> fromSwitchInstruction_value = stack.Pop();
690 context->fromSwitchInstruction = *cast<ValueObject<SwitchInstruction*>*>(fromSwitchInstruction_value.Get());
691 }
692 }
693 public void PreValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
694 {
695 Context* context = cast<Context*>(parsingData->GetContext(Id()));
696 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
697 }
698 public void PostValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
699 {
700 Context* context = cast<Context*>(parsingData->GetContext(Id()));
701 if (matched)
702 {
703 UniquePtr<Object> fromValueInstruction_value = stack.Pop();
704 context->fromValueInstruction = *cast<ValueObject<Instruction*>*>(fromValueInstruction_value.Get());
705 }
706 }
707 public class Context : System.Text.Parsing.Context
708 {
709 public Context() : context(), value(), fromStoreInstruction(), fromArgInstruction(), fromJumpInstruction(), fromBranchInstruction(), fromProcedureCallInstruction(), fromRetInstruction(), fromSwitchInstruction(), fromValueInstruction()
710 {
711 }
712 public cmsx.intermediate.Context* context;
713 public Instruction* value;
714 public Instruction* fromStoreInstruction;
715 public Instruction* fromArgInstruction;
716 public Instruction* fromJumpInstruction;
717 public Instruction* fromBranchInstruction;
718 public Instruction* fromProcedureCallInstruction;
719 public Instruction* fromRetInstruction;
720 public SwitchInstruction* fromSwitchInstruction;
721 public Instruction* fromValueInstruction;
722 }
723 }
724
725 public class StoreInstructionRule : System.Text.Parsing.RuleParser
726 {
727 public StoreInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
728 {
729 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
730 SetValueTypeName(ToUtf32("Instruction*"));
731 }
732 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
733 {
734 parsingData->PushContext(Id(), new Context());
735 Context* context = cast<Context*>(parsingData->GetContext(Id()));
736 UniquePtr<Object> context_value = stack.Pop();
737 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
738 }
739 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
740 {
741 Context* context = cast<Context*>(parsingData->GetContext(Id()));
742 if (matched)
743 {
744 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
745 }
746 parsingData->PopContext(Id());
747 }
748 public override void Link()
749 {
750 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
751 a0ActionParser->SetAction(A0Action);
752 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
753 typeNonterminalParser->SetPre(Pretype);
754 typeNonterminalParser->SetPost(Posttype);
755 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
756 valNonterminalParser->SetPre(Preval);
757 valNonterminalParser->SetPost(Postval);
758 NonterminalParser* ptrTypeNonterminalParser = GetNonterminal(ToUtf32("ptrType"));
759 ptrTypeNonterminalParser->SetPre(PreptrType);
760 ptrTypeNonterminalParser->SetPost(PostptrType);
761 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
762 ptrNonterminalParser->SetPre(Preptr);
763 ptrNonterminalParser->SetPost(Postptr);
764 }
765 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
766 {
767 Context* context = cast<Context*>(parsingData->GetContext(Id()));
768 context->value = new StoreInstruction(context->fromval, context->fromptr, span.lineNumber);
769 }
770 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
771 {
772 Context* context = cast<Context*>(parsingData->GetContext(Id()));
773 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
774 }
775 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
776 {
777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
778 if (matched)
779 {
780 UniquePtr<Object> fromtype_value = stack.Pop();
781 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
782 }
783 }
784 public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
785 {
786 Context* context = cast<Context*>(parsingData->GetContext(Id()));
787 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
788 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
789 }
790 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
791 {
792 Context* context = cast<Context*>(parsingData->GetContext(Id()));
793 if (matched)
794 {
795 UniquePtr<Object> fromval_value = stack.Pop();
796 context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
797 }
798 }
799 public void PreptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
800 {
801 Context* context = cast<Context*>(parsingData->GetContext(Id()));
802 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
803 }
804 public void PostptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
805 {
806 Context* context = cast<Context*>(parsingData->GetContext(Id()));
807 if (matched)
808 {
809 UniquePtr<Object> fromptrType_value = stack.Pop();
810 context->fromptrType = *cast<ValueObject<Type*>*>(fromptrType_value.Get());
811 }
812 }
813 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
814 {
815 Context* context = cast<Context*>(parsingData->GetContext(Id()));
816 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
817 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromptrType)));
818 }
819 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
820 {
821 Context* context = cast<Context*>(parsingData->GetContext(Id()));
822 if (matched)
823 {
824 UniquePtr<Object> fromptr_value = stack.Pop();
825 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
826 }
827 }
828 public class Context : System.Text.Parsing.Context
829 {
830 public Context() : context(), value(), fromtype(), fromval(), fromptrType(), fromptr()
831 {
832 }
833 public cmsx.intermediate.Context* context;
834 public Instruction* value;
835 public Type* fromtype;
836 public Value* fromval;
837 public Type* fromptrType;
838 public Value* fromptr;
839 }
840 }
841
842 public class ArgInstructionRule : System.Text.Parsing.RuleParser
843 {
844 public ArgInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
845 {
846 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
847 SetValueTypeName(ToUtf32("Instruction*"));
848 }
849 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
850 {
851 parsingData->PushContext(Id(), new Context());
852 Context* context = cast<Context*>(parsingData->GetContext(Id()));
853 UniquePtr<Object> context_value = stack.Pop();
854 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
855 }
856 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
857 {
858 Context* context = cast<Context*>(parsingData->GetContext(Id()));
859 if (matched)
860 {
861 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
862 }
863 parsingData->PopContext(Id());
864 }
865 public override void Link()
866 {
867 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
868 a0ActionParser->SetAction(A0Action);
869 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
870 typeNonterminalParser->SetPre(Pretype);
871 typeNonterminalParser->SetPost(Posttype);
872 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
873 argNonterminalParser->SetPre(Prearg);
874 argNonterminalParser->SetPost(Postarg);
875 }
876 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
877 {
878 Context* context = cast<Context*>(parsingData->GetContext(Id()));
879 context->value = new ArgInstruction(context->fromarg, span.lineNumber);
880 }
881 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
882 {
883 Context* context = cast<Context*>(parsingData->GetContext(Id()));
884 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
885 }
886 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
887 {
888 Context* context = cast<Context*>(parsingData->GetContext(Id()));
889 if (matched)
890 {
891 UniquePtr<Object> fromtype_value = stack.Pop();
892 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
893 }
894 }
895 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
896 {
897 Context* context = cast<Context*>(parsingData->GetContext(Id()));
898 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
899 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
900 }
901 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
902 {
903 Context* context = cast<Context*>(parsingData->GetContext(Id()));
904 if (matched)
905 {
906 UniquePtr<Object> fromarg_value = stack.Pop();
907 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
908 }
909 }
910 public class Context : System.Text.Parsing.Context
911 {
912 public Context() : context(), value(), fromtype(), fromarg()
913 {
914 }
915 public cmsx.intermediate.Context* context;
916 public Instruction* value;
917 public Type* fromtype;
918 public Value* fromarg;
919 }
920 }
921
922 public class JumpInstructionRule : System.Text.Parsing.RuleParser
923 {
924 public JumpInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
925 {
926 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
927 SetValueTypeName(ToUtf32("Instruction*"));
928 }
929 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
930 {
931 parsingData->PushContext(Id(), new Context());
932 Context* context = cast<Context*>(parsingData->GetContext(Id()));
933 UniquePtr<Object> context_value = stack.Pop();
934 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
935 }
936 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
937 {
938 Context* context = cast<Context*>(parsingData->GetContext(Id()));
939 if (matched)
940 {
941 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
942 }
943 parsingData->PopContext(Id());
944 }
945 public override void Link()
946 {
947 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
948 a0ActionParser->SetAction(A0Action);
949 NonterminalParser* targetNonterminalParser = GetNonterminal(ToUtf32("target"));
950 targetNonterminalParser->SetPost(Posttarget);
951 }
952 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
953 {
954 Context* context = cast<Context*>(parsingData->GetContext(Id()));
955 context->value = new JumpInstruction(context->fromtarget, span.lineNumber);
956 }
957 public void Posttarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
958 {
959 Context* context = cast<Context*>(parsingData->GetContext(Id()));
960 if (matched)
961 {
962 UniquePtr<Object> fromtarget_value = stack.Pop();
963 context->fromtarget = *cast<ValueObject<uint>*>(fromtarget_value.Get());
964 }
965 }
966 public class Context : System.Text.Parsing.Context
967 {
968 public Context() : context(), value(), fromtarget()
969 {
970 }
971 public cmsx.intermediate.Context* context;
972 public Instruction* value;
973 public uint fromtarget;
974 }
975 }
976
977 public class BranchInstructionRule : System.Text.Parsing.RuleParser
978 {
979 public BranchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
980 {
981 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
982 SetValueTypeName(ToUtf32("Instruction*"));
983 }
984 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
985 {
986 parsingData->PushContext(Id(), new Context());
987 Context* context = cast<Context*>(parsingData->GetContext(Id()));
988 UniquePtr<Object> context_value = stack.Pop();
989 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
990 }
991 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
992 {
993 Context* context = cast<Context*>(parsingData->GetContext(Id()));
994 if (matched)
995 {
996 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
997 }
998 parsingData->PopContext(Id());
999 }
1000 public override void Link()
1001 {
1002 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1003 a0ActionParser->SetAction(A0Action);
1004 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1005 typeNonterminalParser->SetPre(Pretype);
1006 typeNonterminalParser->SetPost(Posttype);
1007 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
1008 condNonterminalParser->SetPre(Precond);
1009 condNonterminalParser->SetPost(Postcond);
1010 NonterminalParser* trueTargetNonterminalParser = GetNonterminal(ToUtf32("trueTarget"));
1011 trueTargetNonterminalParser->SetPost(PosttrueTarget);
1012 NonterminalParser* falseTargetNonterminalParser = GetNonterminal(ToUtf32("falseTarget"));
1013 falseTargetNonterminalParser->SetPost(PostfalseTarget);
1014 }
1015 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1016 {
1017 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1018 context->value = new BranchInstruction(context->fromcond, context->fromtrueTarget, context->fromfalseTarget, span.lineNumber);
1019 }
1020 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1021 {
1022 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1023 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1024 }
1025 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1026 {
1027 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1028 if (matched)
1029 {
1030 UniquePtr<Object> fromtype_value = stack.Pop();
1031 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1032 }
1033 }
1034 public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1035 {
1036 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1037 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1038 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1039 }
1040 public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1041 {
1042 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1043 if (matched)
1044 {
1045 UniquePtr<Object> fromcond_value = stack.Pop();
1046 context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
1047 }
1048 }
1049 public void PosttrueTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1050 {
1051 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1052 if (matched)
1053 {
1054 UniquePtr<Object> fromtrueTarget_value = stack.Pop();
1055 context->fromtrueTarget = *cast<ValueObject<uint>*>(fromtrueTarget_value.Get());
1056 }
1057 }
1058 public void PostfalseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1059 {
1060 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1061 if (matched)
1062 {
1063 UniquePtr<Object> fromfalseTarget_value = stack.Pop();
1064 context->fromfalseTarget = *cast<ValueObject<uint>*>(fromfalseTarget_value.Get());
1065 }
1066 }
1067 public class Context : System.Text.Parsing.Context
1068 {
1069 public Context() : context(), value(), fromtype(), fromcond(), fromtrueTarget(), fromfalseTarget()
1070 {
1071 }
1072 public cmsx.intermediate.Context* context;
1073 public Instruction* value;
1074 public Type* fromtype;
1075 public Value* fromcond;
1076 public uint fromtrueTarget;
1077 public uint fromfalseTarget;
1078 }
1079 }
1080
1081 public class ProcedureCallInstructionRule : System.Text.Parsing.RuleParser
1082 {
1083 public ProcedureCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1084 {
1085 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1086 SetValueTypeName(ToUtf32("Instruction*"));
1087 }
1088 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1089 {
1090 parsingData->PushContext(Id(), new Context());
1091 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1092 UniquePtr<Object> context_value = stack.Pop();
1093 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1094 }
1095 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1096 {
1097 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1098 if (matched)
1099 {
1100 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1101 }
1102 parsingData->PopContext(Id());
1103 }
1104 public override void Link()
1105 {
1106 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1107 a0ActionParser->SetAction(A0Action);
1108 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
1109 functionTypeNonterminalParser->SetPre(PrefunctionType);
1110 functionTypeNonterminalParser->SetPost(PostfunctionType);
1111 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
1112 calleeNonterminalParser->SetPre(Precallee);
1113 calleeNonterminalParser->SetPost(Postcallee);
1114 }
1115 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1116 {
1117 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1118 context->value = new ProcedureCallInstruction(context->fromcallee, span.lineNumber);
1119 }
1120 public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1121 {
1122 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1123 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1124 }
1125 public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1126 {
1127 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1128 if (matched)
1129 {
1130 UniquePtr<Object> fromfunctionType_value = stack.Pop();
1131 context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
1132 }
1133 }
1134 public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1135 {
1136 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1137 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1138 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
1139 }
1140 public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1141 {
1142 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1143 if (matched)
1144 {
1145 UniquePtr<Object> fromcallee_value = stack.Pop();
1146 context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
1147 }
1148 }
1149 public class Context : System.Text.Parsing.Context
1150 {
1151 public Context() : context(), value(), fromfunctionType(), fromcallee()
1152 {
1153 }
1154 public cmsx.intermediate.Context* context;
1155 public Instruction* value;
1156 public Type* fromfunctionType;
1157 public Value* fromcallee;
1158 }
1159 }
1160
1161 public class RetInstructionRule : System.Text.Parsing.RuleParser
1162 {
1163 public RetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1164 {
1165 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1166 SetValueTypeName(ToUtf32("Instruction*"));
1167 }
1168 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1169 {
1170 parsingData->PushContext(Id(), new Context());
1171 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1172 UniquePtr<Object> context_value = stack.Pop();
1173 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1174 }
1175 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1176 {
1177 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1178 if (matched)
1179 {
1180 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1181 }
1182 parsingData->PopContext(Id());
1183 }
1184 public override void Link()
1185 {
1186 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1187 a0ActionParser->SetAction(A0Action);
1188 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1189 a1ActionParser->SetAction(A1Action);
1190 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1191 typeNonterminalParser->SetPre(Pretype);
1192 typeNonterminalParser->SetPost(Posttype);
1193 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
1194 valNonterminalParser->SetPre(Preval);
1195 valNonterminalParser->SetPost(Postval);
1196 }
1197 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1198 {
1199 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1200 context->value = new RetInstruction(null, span.lineNumber);
1201 }
1202 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1203 {
1204 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1205 context->value = new RetInstruction(context->fromval, span.lineNumber);
1206 }
1207 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1208 {
1209 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1210 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1211 }
1212 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1213 {
1214 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1215 if (matched)
1216 {
1217 UniquePtr<Object> fromtype_value = stack.Pop();
1218 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1219 }
1220 }
1221 public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1222 {
1223 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1224 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1225 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1226 }
1227 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1228 {
1229 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1230 if (matched)
1231 {
1232 UniquePtr<Object> fromval_value = stack.Pop();
1233 context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
1234 }
1235 }
1236 public class Context : System.Text.Parsing.Context
1237 {
1238 public Context() : context(), value(), fromtype(), fromval()
1239 {
1240 }
1241 public cmsx.intermediate.Context* context;
1242 public Instruction* value;
1243 public Type* fromtype;
1244 public Value* fromval;
1245 }
1246 }
1247
1248 public class SwitchInstructionRule : System.Text.Parsing.RuleParser
1249 {
1250 public SwitchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1251 {
1252 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1253 SetValueTypeName(ToUtf32("SwitchInstruction*"));
1254 }
1255 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1256 {
1257 parsingData->PushContext(Id(), new Context());
1258 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1259 UniquePtr<Object> context_value = stack.Pop();
1260 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1261 }
1262 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1263 {
1264 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1265 if (matched)
1266 {
1267 stack.Push(UniquePtr<Object>(new ValueObject<SwitchInstruction*>(context->value)));
1268 }
1269 parsingData->PopContext(Id());
1270 }
1271 public override void Link()
1272 {
1273 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1274 a0ActionParser->SetAction(A0Action);
1275 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1276 a1ActionParser->SetAction(A1Action);
1277 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1278 typeNonterminalParser->SetPre(Pretype);
1279 typeNonterminalParser->SetPost(Posttype);
1280 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
1281 condNonterminalParser->SetPre(Precond);
1282 condNonterminalParser->SetPost(Postcond);
1283 NonterminalParser* defaultTargetNonterminalParser = GetNonterminal(ToUtf32("defaultTarget"));
1284 defaultTargetNonterminalParser->SetPost(PostdefaultTarget);
1285 NonterminalParser* caseTypeNonterminalParser = GetNonterminal(ToUtf32("caseType"));
1286 caseTypeNonterminalParser->SetPre(PrecaseType);
1287 caseTypeNonterminalParser->SetPost(PostcaseType);
1288 NonterminalParser* caseValueNonterminalParser = GetNonterminal(ToUtf32("caseValue"));
1289 caseValueNonterminalParser->SetPre(PrecaseValue);
1290 caseValueNonterminalParser->SetPost(PostcaseValue);
1291 NonterminalParser* caseTargetNonterminalParser = GetNonterminal(ToUtf32("caseTarget"));
1292 caseTargetNonterminalParser->SetPost(PostcaseTarget);
1293 }
1294 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1295 {
1296 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1297 context->value = new SwitchInstruction(context->fromcond, context->fromdefaultTarget, span.lineNumber);
1298 }
1299 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1300 {
1301 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1302 context->value->AddCase(context->fromcaseValue, context->fromcaseTarget);
1303 }
1304 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1305 {
1306 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1307 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1308 }
1309 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1310 {
1311 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1312 if (matched)
1313 {
1314 UniquePtr<Object> fromtype_value = stack.Pop();
1315 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1316 }
1317 }
1318 public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1319 {
1320 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1321 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1322 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1323 }
1324 public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1325 {
1326 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1327 if (matched)
1328 {
1329 UniquePtr<Object> fromcond_value = stack.Pop();
1330 context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
1331 }
1332 }
1333 public void PostdefaultTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1334 {
1335 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1336 if (matched)
1337 {
1338 UniquePtr<Object> fromdefaultTarget_value = stack.Pop();
1339 context->fromdefaultTarget = *cast<ValueObject<uint>*>(fromdefaultTarget_value.Get());
1340 }
1341 }
1342 public void PrecaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1343 {
1344 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1345 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1346 }
1347 public void PostcaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1348 {
1349 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1350 if (matched)
1351 {
1352 UniquePtr<Object> fromcaseType_value = stack.Pop();
1353 context->fromcaseType = *cast<ValueObject<Type*>*>(fromcaseType_value.Get());
1354 }
1355 }
1356 public void PrecaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1357 {
1358 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1359 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1360 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromcaseType)));
1361 }
1362 public void PostcaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1363 {
1364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1365 if (matched)
1366 {
1367 UniquePtr<Object> fromcaseValue_value = stack.Pop();
1368 context->fromcaseValue = *cast<ValueObject<Value*>*>(fromcaseValue_value.Get());
1369 }
1370 }
1371 public void PostcaseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1372 {
1373 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1374 if (matched)
1375 {
1376 UniquePtr<Object> fromcaseTarget_value = stack.Pop();
1377 context->fromcaseTarget = *cast<ValueObject<uint>*>(fromcaseTarget_value.Get());
1378 }
1379 }
1380 public class Context : System.Text.Parsing.Context
1381 {
1382 public Context() : context(), value(), fromtype(), fromcond(), fromdefaultTarget(), fromcaseType(), fromcaseValue(), fromcaseTarget()
1383 {
1384 }
1385 public cmsx.intermediate.Context* context;
1386 public SwitchInstruction* value;
1387 public Type* fromtype;
1388 public Value* fromcond;
1389 public uint fromdefaultTarget;
1390 public Type* fromcaseType;
1391 public Value* fromcaseValue;
1392 public uint fromcaseTarget;
1393 }
1394 }
1395
1396 public class ValueInstructionRule : System.Text.Parsing.RuleParser
1397 {
1398 public ValueInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1399 {
1400 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1401 SetValueTypeName(ToUtf32("Instruction*"));
1402 }
1403 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1404 {
1405 parsingData->PushContext(Id(), new Context());
1406 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1407 UniquePtr<Object> context_value = stack.Pop();
1408 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1409 }
1410 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1411 {
1412 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1413 if (matched)
1414 {
1415 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1416 }
1417 parsingData->PopContext(Id());
1418 }
1419 public override void Link()
1420 {
1421 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1422 a0ActionParser->SetAction(A0Action);
1423 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
1424 typeNonterminalParser->SetPre(Pretype);
1425 typeNonterminalParser->SetPost(Posttype);
1426 NonterminalParser* resultNonterminalParser = GetNonterminal(ToUtf32("result"));
1427 resultNonterminalParser->SetPre(Preresult);
1428 resultNonterminalParser->SetPost(Postresult);
1429 NonterminalParser* operationNonterminalParser = GetNonterminal(ToUtf32("Operation"));
1430 operationNonterminalParser->SetPre(PreOperation);
1431 operationNonterminalParser->SetPost(PostOperation);
1432 }
1433 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1434 {
1435 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1436 context->value = context->fromOperation;
1437 }
1438 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1439 {
1440 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1441 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1442 }
1443 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1444 {
1445 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1446 if (matched)
1447 {
1448 UniquePtr<Object> fromtype_value = stack.Pop();
1449 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
1450 }
1451 }
1452 public void Preresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1453 {
1454 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1455 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1456 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
1457 }
1458 public void Postresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1459 {
1460 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1461 if (matched)
1462 {
1463 UniquePtr<Object> fromresult_value = stack.Pop();
1464 context->fromresult = *cast<ValueObject<Value*>*>(fromresult_value.Get());
1465 }
1466 }
1467 public void PreOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1468 {
1469 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1470 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1471 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->fromresult)));
1472 }
1473 public void PostOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1474 {
1475 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1476 if (matched)
1477 {
1478 UniquePtr<Object> fromOperation_value = stack.Pop();
1479 context->fromOperation = *cast<ValueObject<Instruction*>*>(fromOperation_value.Get());
1480 }
1481 }
1482 public class Context : System.Text.Parsing.Context
1483 {
1484 public Context() : context(), value(), fromtype(), fromresult(), fromOperation()
1485 {
1486 }
1487 public cmsx.intermediate.Context* context;
1488 public Instruction* value;
1489 public Type* fromtype;
1490 public Value* fromresult;
1491 public Instruction* fromOperation;
1492 }
1493 }
1494
1495 public class OperationRule : System.Text.Parsing.RuleParser
1496 {
1497 public OperationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1498 {
1499 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1500 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
1501 SetValueTypeName(ToUtf32("Instruction*"));
1502 }
1503 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1504 {
1505 parsingData->PushContext(Id(), new Context());
1506 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1507 UniquePtr<Object> result_value = stack.Pop();
1508 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
1509 UniquePtr<Object> context_value = stack.Pop();
1510 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1511 }
1512 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1513 {
1514 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1515 if (matched)
1516 {
1517 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1518 }
1519 parsingData->PopContext(Id());
1520 }
1521 public override void Link()
1522 {
1523 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1524 a0ActionParser->SetAction(A0Action);
1525 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1526 a1ActionParser->SetAction(A1Action);
1527 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1528 a2ActionParser->SetAction(A2Action);
1529 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1530 a3ActionParser->SetAction(A3Action);
1531 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1532 a4ActionParser->SetAction(A4Action);
1533 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1534 a5ActionParser->SetAction(A5Action);
1535 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1536 a6ActionParser->SetAction(A6Action);
1537 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
1538 a7ActionParser->SetAction(A7Action);
1539 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
1540 a8ActionParser->SetAction(A8Action);
1541 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
1542 a9ActionParser->SetAction(A9Action);
1543 NonterminalParser* unaryInstructionNonterminalParser = GetNonterminal(ToUtf32("UnaryInstruction"));
1544 unaryInstructionNonterminalParser->SetPre(PreUnaryInstruction);
1545 unaryInstructionNonterminalParser->SetPost(PostUnaryInstruction);
1546 NonterminalParser* binaryInstructionNonterminalParser = GetNonterminal(ToUtf32("BinaryInstruction"));
1547 binaryInstructionNonterminalParser->SetPre(PreBinaryInstruction);
1548 binaryInstructionNonterminalParser->SetPost(PostBinaryInstruction);
1549 NonterminalParser* paramInstructionNonterminalParser = GetNonterminal(ToUtf32("ParamInstruction"));
1550 paramInstructionNonterminalParser->SetPre(PreParamInstruction);
1551 paramInstructionNonterminalParser->SetPost(PostParamInstruction);
1552 NonterminalParser* localInstructionNonterminalParser = GetNonterminal(ToUtf32("LocalInstruction"));
1553 localInstructionNonterminalParser->SetPre(PreLocalInstruction);
1554 localInstructionNonterminalParser->SetPost(PostLocalInstruction);
1555 NonterminalParser* loadInstructionNonterminalParser = GetNonterminal(ToUtf32("LoadInstruction"));
1556 loadInstructionNonterminalParser->SetPre(PreLoadInstruction);
1557 loadInstructionNonterminalParser->SetPost(PostLoadInstruction);
1558 NonterminalParser* elemAddrInstructionNonterminalParser = GetNonterminal(ToUtf32("ElemAddrInstruction"));
1559 elemAddrInstructionNonterminalParser->SetPre(PreElemAddrInstruction);
1560 elemAddrInstructionNonterminalParser->SetPost(PostElemAddrInstruction);
1561 NonterminalParser* ptrOffsetInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrOffsetInstruction"));
1562 ptrOffsetInstructionNonterminalParser->SetPre(PrePtrOffsetInstruction);
1563 ptrOffsetInstructionNonterminalParser->SetPost(PostPtrOffsetInstruction);
1564 NonterminalParser* ptrDiffInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrDiffInstruction"));
1565 ptrDiffInstructionNonterminalParser->SetPre(PrePtrDiffInstruction);
1566 ptrDiffInstructionNonterminalParser->SetPost(PostPtrDiffInstruction);
1567 NonterminalParser* functionCallInstructionNonterminalParser = GetNonterminal(ToUtf32("FunctionCallInstruction"));
1568 functionCallInstructionNonterminalParser->SetPre(PreFunctionCallInstruction);
1569 functionCallInstructionNonterminalParser->SetPost(PostFunctionCallInstruction);
1570 NonterminalParser* trapInstructionNonterminalParser = GetNonterminal(ToUtf32("TrapInstruction"));
1571 trapInstructionNonterminalParser->SetPre(PreTrapInstruction);
1572 trapInstructionNonterminalParser->SetPost(PostTrapInstruction);
1573 }
1574 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1575 {
1576 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1577 context->value = context->fromUnaryInstruction;
1578 }
1579 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1580 {
1581 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1582 context->value = context->fromBinaryInstruction;
1583 }
1584 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1585 {
1586 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1587 context->value = context->fromParamInstruction;
1588 }
1589 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1590 {
1591 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1592 context->value = context->fromLocalInstruction;
1593 }
1594 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1595 {
1596 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1597 context->value = context->fromLoadInstruction;
1598 }
1599 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1600 {
1601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1602 context->value = context->fromElemAddrInstruction;
1603 }
1604 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1605 {
1606 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1607 context->value = context->fromPtrOffsetInstruction;
1608 }
1609 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1610 {
1611 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1612 context->value = context->fromPtrDiffInstruction;
1613 }
1614 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1615 {
1616 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1617 context->value = context->fromFunctionCallInstruction;
1618 }
1619 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1620 {
1621 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1622 context->value = context->fromTrapInstruction;
1623 }
1624 public void PreUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1625 {
1626 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1627 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1628 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1629 }
1630 public void PostUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1631 {
1632 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1633 if (matched)
1634 {
1635 UniquePtr<Object> fromUnaryInstruction_value = stack.Pop();
1636 context->fromUnaryInstruction = *cast<ValueObject<Instruction*>*>(fromUnaryInstruction_value.Get());
1637 }
1638 }
1639 public void PreBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1640 {
1641 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1642 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1643 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1644 }
1645 public void PostBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1646 {
1647 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1648 if (matched)
1649 {
1650 UniquePtr<Object> fromBinaryInstruction_value = stack.Pop();
1651 context->fromBinaryInstruction = *cast<ValueObject<Instruction*>*>(fromBinaryInstruction_value.Get());
1652 }
1653 }
1654 public void PreParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1655 {
1656 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1657 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1658 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1659 }
1660 public void PostParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1661 {
1662 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1663 if (matched)
1664 {
1665 UniquePtr<Object> fromParamInstruction_value = stack.Pop();
1666 context->fromParamInstruction = *cast<ValueObject<Instruction*>*>(fromParamInstruction_value.Get());
1667 }
1668 }
1669 public void PreLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1670 {
1671 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1672 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1673 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1674 }
1675 public void PostLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1676 {
1677 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1678 if (matched)
1679 {
1680 UniquePtr<Object> fromLocalInstruction_value = stack.Pop();
1681 context->fromLocalInstruction = *cast<ValueObject<Instruction*>*>(fromLocalInstruction_value.Get());
1682 }
1683 }
1684 public void PreLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1685 {
1686 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1687 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1688 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1689 }
1690 public void PostLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1691 {
1692 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1693 if (matched)
1694 {
1695 UniquePtr<Object> fromLoadInstruction_value = stack.Pop();
1696 context->fromLoadInstruction = *cast<ValueObject<Instruction*>*>(fromLoadInstruction_value.Get());
1697 }
1698 }
1699 public void PreElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1700 {
1701 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1702 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1703 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1704 }
1705 public void PostElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1706 {
1707 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1708 if (matched)
1709 {
1710 UniquePtr<Object> fromElemAddrInstruction_value = stack.Pop();
1711 context->fromElemAddrInstruction = *cast<ValueObject<Instruction*>*>(fromElemAddrInstruction_value.Get());
1712 }
1713 }
1714 public void PrePtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1715 {
1716 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1717 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1718 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1719 }
1720 public void PostPtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1721 {
1722 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1723 if (matched)
1724 {
1725 UniquePtr<Object> fromPtrOffsetInstruction_value = stack.Pop();
1726 context->fromPtrOffsetInstruction = *cast<ValueObject<Instruction*>*>(fromPtrOffsetInstruction_value.Get());
1727 }
1728 }
1729 public void PrePtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1730 {
1731 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1732 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1733 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1734 }
1735 public void PostPtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1736 {
1737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1738 if (matched)
1739 {
1740 UniquePtr<Object> fromPtrDiffInstruction_value = stack.Pop();
1741 context->fromPtrDiffInstruction = *cast<ValueObject<Instruction*>*>(fromPtrDiffInstruction_value.Get());
1742 }
1743 }
1744 public void PreFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1745 {
1746 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1747 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1748 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1749 }
1750 public void PostFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1751 {
1752 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1753 if (matched)
1754 {
1755 UniquePtr<Object> fromFunctionCallInstruction_value = stack.Pop();
1756 context->fromFunctionCallInstruction = *cast<ValueObject<Instruction*>*>(fromFunctionCallInstruction_value.Get());
1757 }
1758 }
1759 public void PreTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1760 {
1761 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1762 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1763 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1764 }
1765 public void PostTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1766 {
1767 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1768 if (matched)
1769 {
1770 UniquePtr<Object> fromTrapInstruction_value = stack.Pop();
1771 context->fromTrapInstruction = *cast<ValueObject<Instruction*>*>(fromTrapInstruction_value.Get());
1772 }
1773 }
1774 public class Context : System.Text.Parsing.Context
1775 {
1776 public Context() : context(), result(), value(), fromUnaryInstruction(), fromBinaryInstruction(), fromParamInstruction(), fromLocalInstruction(), fromLoadInstruction(), fromElemAddrInstruction(), fromPtrOffsetInstruction(), fromPtrDiffInstruction(), fromFunctionCallInstruction(), fromTrapInstruction()
1777 {
1778 }
1779 public cmsx.intermediate.Context* context;
1780 public Value* result;
1781 public Instruction* value;
1782 public Instruction* fromUnaryInstruction;
1783 public Instruction* fromBinaryInstruction;
1784 public Instruction* fromParamInstruction;
1785 public Instruction* fromLocalInstruction;
1786 public Instruction* fromLoadInstruction;
1787 public Instruction* fromElemAddrInstruction;
1788 public Instruction* fromPtrOffsetInstruction;
1789 public Instruction* fromPtrDiffInstruction;
1790 public Instruction* fromFunctionCallInstruction;
1791 public Instruction* fromTrapInstruction;
1792 }
1793 }
1794
1795 public class UnaryInstructionRule : System.Text.Parsing.RuleParser
1796 {
1797 public UnaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
1798 {
1799 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
1800 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
1801 SetValueTypeName(ToUtf32("Instruction*"));
1802 }
1803 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1804 {
1805 parsingData->PushContext(Id(), new Context());
1806 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1807 UniquePtr<Object> result_value = stack.Pop();
1808 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
1809 UniquePtr<Object> context_value = stack.Pop();
1810 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
1811 }
1812 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1813 {
1814 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1815 if (matched)
1816 {
1817 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
1818 }
1819 parsingData->PopContext(Id());
1820 }
1821 public override void Link()
1822 {
1823 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
1824 a0ActionParser->SetAction(A0Action);
1825 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
1826 a1ActionParser->SetAction(A1Action);
1827 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
1828 a2ActionParser->SetAction(A2Action);
1829 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
1830 a3ActionParser->SetAction(A3Action);
1831 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
1832 a4ActionParser->SetAction(A4Action);
1833 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
1834 a5ActionParser->SetAction(A5Action);
1835 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
1836 a6ActionParser->SetAction(A6Action);
1837 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
1838 a7ActionParser->SetAction(A7Action);
1839 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
1840 a8ActionParser->SetAction(A8Action);
1841 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
1842 a9ActionParser->SetAction(A9Action);
1843 NonterminalParser* notInstructionNonterminalParser = GetNonterminal(ToUtf32("NotInstruction"));
1844 notInstructionNonterminalParser->SetPre(PreNotInstruction);
1845 notInstructionNonterminalParser->SetPost(PostNotInstruction);
1846 NonterminalParser* negInstructionNonterminalParser = GetNonterminal(ToUtf32("NegInstruction"));
1847 negInstructionNonterminalParser->SetPre(PreNegInstruction);
1848 negInstructionNonterminalParser->SetPost(PostNegInstruction);
1849 NonterminalParser* signExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("SignExtendInstruction"));
1850 signExtendInstructionNonterminalParser->SetPre(PreSignExtendInstruction);
1851 signExtendInstructionNonterminalParser->SetPost(PostSignExtendInstruction);
1852 NonterminalParser* zeroExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("ZeroExtendInstruction"));
1853 zeroExtendInstructionNonterminalParser->SetPre(PreZeroExtendInstruction);
1854 zeroExtendInstructionNonterminalParser->SetPost(PostZeroExtendInstruction);
1855 NonterminalParser* truncateInstructionNonterminalParser = GetNonterminal(ToUtf32("TruncateInstruction"));
1856 truncateInstructionNonterminalParser->SetPre(PreTruncateInstruction);
1857 truncateInstructionNonterminalParser->SetPost(PostTruncateInstruction);
1858 NonterminalParser* bitCastInstructionNonterminalParser = GetNonterminal(ToUtf32("BitCastInstruction"));
1859 bitCastInstructionNonterminalParser->SetPre(PreBitCastInstruction);
1860 bitCastInstructionNonterminalParser->SetPost(PostBitCastInstruction);
1861 NonterminalParser* intToFloatInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToFloatInstruction"));
1862 intToFloatInstructionNonterminalParser->SetPre(PreIntToFloatInstruction);
1863 intToFloatInstructionNonterminalParser->SetPost(PostIntToFloatInstruction);
1864 NonterminalParser* floatToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("FloatToIntInstruction"));
1865 floatToIntInstructionNonterminalParser->SetPre(PreFloatToIntInstruction);
1866 floatToIntInstructionNonterminalParser->SetPost(PostFloatToIntInstruction);
1867 NonterminalParser* intToPtrInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToPtrInstruction"));
1868 intToPtrInstructionNonterminalParser->SetPre(PreIntToPtrInstruction);
1869 intToPtrInstructionNonterminalParser->SetPost(PostIntToPtrInstruction);
1870 NonterminalParser* ptrToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrToIntInstruction"));
1871 ptrToIntInstructionNonterminalParser->SetPre(PrePtrToIntInstruction);
1872 ptrToIntInstructionNonterminalParser->SetPost(PostPtrToIntInstruction);
1873 }
1874 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1875 {
1876 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1877 context->value = context->fromNotInstruction;
1878 }
1879 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1880 {
1881 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1882 context->value = context->fromNegInstruction;
1883 }
1884 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1885 {
1886 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1887 context->value = context->fromSignExtendInstruction;
1888 }
1889 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1890 {
1891 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1892 context->value = context->fromZeroExtendInstruction;
1893 }
1894 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1895 {
1896 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1897 context->value = context->fromTruncateInstruction;
1898 }
1899 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1900 {
1901 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1902 context->value = context->fromBitCastInstruction;
1903 }
1904 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1905 {
1906 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1907 context->value = context->fromIntToFloatInstruction;
1908 }
1909 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1910 {
1911 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1912 context->value = context->fromFloatToIntInstruction;
1913 }
1914 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1915 {
1916 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1917 context->value = context->fromIntToPtrInstruction;
1918 }
1919 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
1920 {
1921 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1922 context->value = context->fromPtrToIntInstruction;
1923 }
1924 public void PreNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1925 {
1926 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1927 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1928 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1929 }
1930 public void PostNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1931 {
1932 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1933 if (matched)
1934 {
1935 UniquePtr<Object> fromNotInstruction_value = stack.Pop();
1936 context->fromNotInstruction = *cast<ValueObject<Instruction*>*>(fromNotInstruction_value.Get());
1937 }
1938 }
1939 public void PreNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1940 {
1941 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1942 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1943 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1944 }
1945 public void PostNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1946 {
1947 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1948 if (matched)
1949 {
1950 UniquePtr<Object> fromNegInstruction_value = stack.Pop();
1951 context->fromNegInstruction = *cast<ValueObject<Instruction*>*>(fromNegInstruction_value.Get());
1952 }
1953 }
1954 public void PreSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1955 {
1956 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1957 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1958 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1959 }
1960 public void PostSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1961 {
1962 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1963 if (matched)
1964 {
1965 UniquePtr<Object> fromSignExtendInstruction_value = stack.Pop();
1966 context->fromSignExtendInstruction = *cast<ValueObject<Instruction*>*>(fromSignExtendInstruction_value.Get());
1967 }
1968 }
1969 public void PreZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1970 {
1971 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1972 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1973 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1974 }
1975 public void PostZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1976 {
1977 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1978 if (matched)
1979 {
1980 UniquePtr<Object> fromZeroExtendInstruction_value = stack.Pop();
1981 context->fromZeroExtendInstruction = *cast<ValueObject<Instruction*>*>(fromZeroExtendInstruction_value.Get());
1982 }
1983 }
1984 public void PreTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
1985 {
1986 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1987 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
1988 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
1989 }
1990 public void PostTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
1991 {
1992 Context* context = cast<Context*>(parsingData->GetContext(Id()));
1993 if (matched)
1994 {
1995 UniquePtr<Object> fromTruncateInstruction_value = stack.Pop();
1996 context->fromTruncateInstruction = *cast<ValueObject<Instruction*>*>(fromTruncateInstruction_value.Get());
1997 }
1998 }
1999 public void PreBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2000 {
2001 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2002 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2003 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2004 }
2005 public void PostBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2006 {
2007 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2008 if (matched)
2009 {
2010 UniquePtr<Object> fromBitCastInstruction_value = stack.Pop();
2011 context->fromBitCastInstruction = *cast<ValueObject<Instruction*>*>(fromBitCastInstruction_value.Get());
2012 }
2013 }
2014 public void PreIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2015 {
2016 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2017 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2018 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2019 }
2020 public void PostIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2021 {
2022 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2023 if (matched)
2024 {
2025 UniquePtr<Object> fromIntToFloatInstruction_value = stack.Pop();
2026 context->fromIntToFloatInstruction = *cast<ValueObject<Instruction*>*>(fromIntToFloatInstruction_value.Get());
2027 }
2028 }
2029 public void PreFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2030 {
2031 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2032 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2033 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2034 }
2035 public void PostFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2036 {
2037 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2038 if (matched)
2039 {
2040 UniquePtr<Object> fromFloatToIntInstruction_value = stack.Pop();
2041 context->fromFloatToIntInstruction = *cast<ValueObject<Instruction*>*>(fromFloatToIntInstruction_value.Get());
2042 }
2043 }
2044 public void PreIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2045 {
2046 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2047 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2048 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2049 }
2050 public void PostIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2051 {
2052 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2053 if (matched)
2054 {
2055 UniquePtr<Object> fromIntToPtrInstruction_value = stack.Pop();
2056 context->fromIntToPtrInstruction = *cast<ValueObject<Instruction*>*>(fromIntToPtrInstruction_value.Get());
2057 }
2058 }
2059 public void PrePtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2060 {
2061 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2062 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2063 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2064 }
2065 public void PostPtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2066 {
2067 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2068 if (matched)
2069 {
2070 UniquePtr<Object> fromPtrToIntInstruction_value = stack.Pop();
2071 context->fromPtrToIntInstruction = *cast<ValueObject<Instruction*>*>(fromPtrToIntInstruction_value.Get());
2072 }
2073 }
2074 public class Context : System.Text.Parsing.Context
2075 {
2076 public Context() : context(), result(), value(), fromNotInstruction(), fromNegInstruction(), fromSignExtendInstruction(), fromZeroExtendInstruction(), fromTruncateInstruction(), fromBitCastInstruction(), fromIntToFloatInstruction(), fromFloatToIntInstruction(), fromIntToPtrInstruction(), fromPtrToIntInstruction()
2077 {
2078 }
2079 public cmsx.intermediate.Context* context;
2080 public Value* result;
2081 public Instruction* value;
2082 public Instruction* fromNotInstruction;
2083 public Instruction* fromNegInstruction;
2084 public Instruction* fromSignExtendInstruction;
2085 public Instruction* fromZeroExtendInstruction;
2086 public Instruction* fromTruncateInstruction;
2087 public Instruction* fromBitCastInstruction;
2088 public Instruction* fromIntToFloatInstruction;
2089 public Instruction* fromFloatToIntInstruction;
2090 public Instruction* fromIntToPtrInstruction;
2091 public Instruction* fromPtrToIntInstruction;
2092 }
2093 }
2094
2095 public class NotInstructionRule : System.Text.Parsing.RuleParser
2096 {
2097 public NotInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2098 {
2099 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2100 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2101 SetValueTypeName(ToUtf32("Instruction*"));
2102 }
2103 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2104 {
2105 parsingData->PushContext(Id(), new Context());
2106 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2107 UniquePtr<Object> result_value = stack.Pop();
2108 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2109 UniquePtr<Object> context_value = stack.Pop();
2110 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2111 }
2112 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2113 {
2114 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2115 if (matched)
2116 {
2117 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2118 }
2119 parsingData->PopContext(Id());
2120 }
2121 public override void Link()
2122 {
2123 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2124 a0ActionParser->SetAction(A0Action);
2125 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2126 argNonterminalParser->SetPre(Prearg);
2127 argNonterminalParser->SetPost(Postarg);
2128 }
2129 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2130 {
2131 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2132 context->value = new NotInstruction(context->result, context->fromarg, span.lineNumber);
2133 }
2134 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2135 {
2136 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2137 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2138 }
2139 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2140 {
2141 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2142 if (matched)
2143 {
2144 UniquePtr<Object> fromarg_value = stack.Pop();
2145 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2146 }
2147 }
2148 public class Context : System.Text.Parsing.Context
2149 {
2150 public Context() : context(), result(), value(), fromarg()
2151 {
2152 }
2153 public cmsx.intermediate.Context* context;
2154 public Value* result;
2155 public Instruction* value;
2156 public Value* fromarg;
2157 }
2158 }
2159
2160 public class NegInstructionRule : System.Text.Parsing.RuleParser
2161 {
2162 public NegInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2163 {
2164 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2165 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2166 SetValueTypeName(ToUtf32("Instruction*"));
2167 }
2168 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2169 {
2170 parsingData->PushContext(Id(), new Context());
2171 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2172 UniquePtr<Object> result_value = stack.Pop();
2173 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2174 UniquePtr<Object> context_value = stack.Pop();
2175 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2176 }
2177 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2178 {
2179 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2180 if (matched)
2181 {
2182 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2183 }
2184 parsingData->PopContext(Id());
2185 }
2186 public override void Link()
2187 {
2188 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2189 a0ActionParser->SetAction(A0Action);
2190 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2191 argNonterminalParser->SetPre(Prearg);
2192 argNonterminalParser->SetPost(Postarg);
2193 }
2194 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2195 {
2196 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2197 context->value = new NegInstruction(context->result, context->fromarg, span.lineNumber);
2198 }
2199 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2200 {
2201 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2202 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2203 }
2204 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2205 {
2206 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2207 if (matched)
2208 {
2209 UniquePtr<Object> fromarg_value = stack.Pop();
2210 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2211 }
2212 }
2213 public class Context : System.Text.Parsing.Context
2214 {
2215 public Context() : context(), result(), value(), fromarg()
2216 {
2217 }
2218 public cmsx.intermediate.Context* context;
2219 public Value* result;
2220 public Instruction* value;
2221 public Value* fromarg;
2222 }
2223 }
2224
2225 public class SignExtendInstructionRule : System.Text.Parsing.RuleParser
2226 {
2227 public SignExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2228 {
2229 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2230 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2231 SetValueTypeName(ToUtf32("Instruction*"));
2232 }
2233 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2234 {
2235 parsingData->PushContext(Id(), new Context());
2236 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2237 UniquePtr<Object> result_value = stack.Pop();
2238 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2239 UniquePtr<Object> context_value = stack.Pop();
2240 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2241 }
2242 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2243 {
2244 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2245 if (matched)
2246 {
2247 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2248 }
2249 parsingData->PopContext(Id());
2250 }
2251 public override void Link()
2252 {
2253 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2254 a0ActionParser->SetAction(A0Action);
2255 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2256 argNonterminalParser->SetPre(Prearg);
2257 argNonterminalParser->SetPost(Postarg);
2258 }
2259 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2260 {
2261 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2262 context->value = new SignExtendInstruction(context->result, context->fromarg, span.lineNumber);
2263 }
2264 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2265 {
2266 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2267 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2268 }
2269 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2270 {
2271 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2272 if (matched)
2273 {
2274 UniquePtr<Object> fromarg_value = stack.Pop();
2275 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2276 }
2277 }
2278 public class Context : System.Text.Parsing.Context
2279 {
2280 public Context() : context(), result(), value(), fromarg()
2281 {
2282 }
2283 public cmsx.intermediate.Context* context;
2284 public Value* result;
2285 public Instruction* value;
2286 public Value* fromarg;
2287 }
2288 }
2289
2290 public class ZeroExtendInstructionRule : System.Text.Parsing.RuleParser
2291 {
2292 public ZeroExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2293 {
2294 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2295 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2296 SetValueTypeName(ToUtf32("Instruction*"));
2297 }
2298 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2299 {
2300 parsingData->PushContext(Id(), new Context());
2301 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2302 UniquePtr<Object> result_value = stack.Pop();
2303 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2304 UniquePtr<Object> context_value = stack.Pop();
2305 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2306 }
2307 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2308 {
2309 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2310 if (matched)
2311 {
2312 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2313 }
2314 parsingData->PopContext(Id());
2315 }
2316 public override void Link()
2317 {
2318 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2319 a0ActionParser->SetAction(A0Action);
2320 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2321 argNonterminalParser->SetPre(Prearg);
2322 argNonterminalParser->SetPost(Postarg);
2323 }
2324 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2325 {
2326 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2327 context->value = new ZeroExtendInstruction(context->result, context->fromarg, span.lineNumber);
2328 }
2329 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2330 {
2331 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2332 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2333 }
2334 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2335 {
2336 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2337 if (matched)
2338 {
2339 UniquePtr<Object> fromarg_value = stack.Pop();
2340 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2341 }
2342 }
2343 public class Context : System.Text.Parsing.Context
2344 {
2345 public Context() : context(), result(), value(), fromarg()
2346 {
2347 }
2348 public cmsx.intermediate.Context* context;
2349 public Value* result;
2350 public Instruction* value;
2351 public Value* fromarg;
2352 }
2353 }
2354
2355 public class TruncateInstructionRule : System.Text.Parsing.RuleParser
2356 {
2357 public TruncateInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2358 {
2359 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2360 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2361 SetValueTypeName(ToUtf32("Instruction*"));
2362 }
2363 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2364 {
2365 parsingData->PushContext(Id(), new Context());
2366 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2367 UniquePtr<Object> result_value = stack.Pop();
2368 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2369 UniquePtr<Object> context_value = stack.Pop();
2370 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2371 }
2372 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2373 {
2374 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2375 if (matched)
2376 {
2377 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2378 }
2379 parsingData->PopContext(Id());
2380 }
2381 public override void Link()
2382 {
2383 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2384 a0ActionParser->SetAction(A0Action);
2385 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2386 argNonterminalParser->SetPre(Prearg);
2387 argNonterminalParser->SetPost(Postarg);
2388 }
2389 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2390 {
2391 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2392 context->value = new TruncateInstruction(context->result, context->fromarg, span.lineNumber);
2393 }
2394 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2395 {
2396 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2397 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2398 }
2399 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2400 {
2401 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2402 if (matched)
2403 {
2404 UniquePtr<Object> fromarg_value = stack.Pop();
2405 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2406 }
2407 }
2408 public class Context : System.Text.Parsing.Context
2409 {
2410 public Context() : context(), result(), value(), fromarg()
2411 {
2412 }
2413 public cmsx.intermediate.Context* context;
2414 public Value* result;
2415 public Instruction* value;
2416 public Value* fromarg;
2417 }
2418 }
2419
2420 public class BitCastInstructionRule : System.Text.Parsing.RuleParser
2421 {
2422 public BitCastInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2423 {
2424 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2425 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2426 SetValueTypeName(ToUtf32("Instruction*"));
2427 }
2428 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2429 {
2430 parsingData->PushContext(Id(), new Context());
2431 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2432 UniquePtr<Object> result_value = stack.Pop();
2433 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2434 UniquePtr<Object> context_value = stack.Pop();
2435 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2436 }
2437 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2438 {
2439 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2440 if (matched)
2441 {
2442 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2443 }
2444 parsingData->PopContext(Id());
2445 }
2446 public override void Link()
2447 {
2448 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2449 a0ActionParser->SetAction(A0Action);
2450 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2451 argNonterminalParser->SetPre(Prearg);
2452 argNonterminalParser->SetPost(Postarg);
2453 }
2454 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2455 {
2456 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2457 context->value = new BitCastInstruction(context->result, context->fromarg, span.lineNumber);
2458 }
2459 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2460 {
2461 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2462 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2463 }
2464 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2465 {
2466 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2467 if (matched)
2468 {
2469 UniquePtr<Object> fromarg_value = stack.Pop();
2470 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2471 }
2472 }
2473 public class Context : System.Text.Parsing.Context
2474 {
2475 public Context() : context(), result(), value(), fromarg()
2476 {
2477 }
2478 public cmsx.intermediate.Context* context;
2479 public Value* result;
2480 public Instruction* value;
2481 public Value* fromarg;
2482 }
2483 }
2484
2485 public class IntToFloatInstructionRule : System.Text.Parsing.RuleParser
2486 {
2487 public IntToFloatInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2488 {
2489 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2490 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2491 SetValueTypeName(ToUtf32("Instruction*"));
2492 }
2493 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2494 {
2495 parsingData->PushContext(Id(), new Context());
2496 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2497 UniquePtr<Object> result_value = stack.Pop();
2498 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2499 UniquePtr<Object> context_value = stack.Pop();
2500 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2501 }
2502 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2503 {
2504 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2505 if (matched)
2506 {
2507 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2508 }
2509 parsingData->PopContext(Id());
2510 }
2511 public override void Link()
2512 {
2513 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2514 a0ActionParser->SetAction(A0Action);
2515 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2516 argNonterminalParser->SetPre(Prearg);
2517 argNonterminalParser->SetPost(Postarg);
2518 }
2519 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2520 {
2521 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2522 context->value = new IntToFloatInstruction(context->result, context->fromarg, span.lineNumber);
2523 }
2524 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2525 {
2526 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2527 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2528 }
2529 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2530 {
2531 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2532 if (matched)
2533 {
2534 UniquePtr<Object> fromarg_value = stack.Pop();
2535 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2536 }
2537 }
2538 public class Context : System.Text.Parsing.Context
2539 {
2540 public Context() : context(), result(), value(), fromarg()
2541 {
2542 }
2543 public cmsx.intermediate.Context* context;
2544 public Value* result;
2545 public Instruction* value;
2546 public Value* fromarg;
2547 }
2548 }
2549
2550 public class FloatToIntInstructionRule : System.Text.Parsing.RuleParser
2551 {
2552 public FloatToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2553 {
2554 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2555 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2556 SetValueTypeName(ToUtf32("Instruction*"));
2557 }
2558 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2559 {
2560 parsingData->PushContext(Id(), new Context());
2561 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2562 UniquePtr<Object> result_value = stack.Pop();
2563 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2564 UniquePtr<Object> context_value = stack.Pop();
2565 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2566 }
2567 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2568 {
2569 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2570 if (matched)
2571 {
2572 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2573 }
2574 parsingData->PopContext(Id());
2575 }
2576 public override void Link()
2577 {
2578 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2579 a0ActionParser->SetAction(A0Action);
2580 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2581 argNonterminalParser->SetPre(Prearg);
2582 argNonterminalParser->SetPost(Postarg);
2583 }
2584 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2585 {
2586 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2587 context->value = new FloatToIntInstruction(context->result, context->fromarg, span.lineNumber);
2588 }
2589 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2590 {
2591 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2592 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2593 }
2594 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2595 {
2596 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2597 if (matched)
2598 {
2599 UniquePtr<Object> fromarg_value = stack.Pop();
2600 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2601 }
2602 }
2603 public class Context : System.Text.Parsing.Context
2604 {
2605 public Context() : context(), result(), value(), fromarg()
2606 {
2607 }
2608 public cmsx.intermediate.Context* context;
2609 public Value* result;
2610 public Instruction* value;
2611 public Value* fromarg;
2612 }
2613 }
2614
2615 public class IntToPtrInstructionRule : System.Text.Parsing.RuleParser
2616 {
2617 public IntToPtrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2618 {
2619 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2620 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2621 SetValueTypeName(ToUtf32("Instruction*"));
2622 }
2623 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2624 {
2625 parsingData->PushContext(Id(), new Context());
2626 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2627 UniquePtr<Object> result_value = stack.Pop();
2628 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2629 UniquePtr<Object> context_value = stack.Pop();
2630 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2631 }
2632 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2633 {
2634 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2635 if (matched)
2636 {
2637 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2638 }
2639 parsingData->PopContext(Id());
2640 }
2641 public override void Link()
2642 {
2643 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2644 a0ActionParser->SetAction(A0Action);
2645 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2646 argNonterminalParser->SetPre(Prearg);
2647 argNonterminalParser->SetPost(Postarg);
2648 }
2649 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2650 {
2651 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2652 context->value = new IntToPtrInstruction(context->result, context->fromarg, span.lineNumber);
2653 }
2654 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2655 {
2656 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2657 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2658 }
2659 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2660 {
2661 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2662 if (matched)
2663 {
2664 UniquePtr<Object> fromarg_value = stack.Pop();
2665 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2666 }
2667 }
2668 public class Context : System.Text.Parsing.Context
2669 {
2670 public Context() : context(), result(), value(), fromarg()
2671 {
2672 }
2673 public cmsx.intermediate.Context* context;
2674 public Value* result;
2675 public Instruction* value;
2676 public Value* fromarg;
2677 }
2678 }
2679
2680 public class PtrToIntInstructionRule : System.Text.Parsing.RuleParser
2681 {
2682 public PtrToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2683 {
2684 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2685 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2686 SetValueTypeName(ToUtf32("Instruction*"));
2687 }
2688 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2689 {
2690 parsingData->PushContext(Id(), new Context());
2691 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2692 UniquePtr<Object> result_value = stack.Pop();
2693 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2694 UniquePtr<Object> context_value = stack.Pop();
2695 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2696 }
2697 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2698 {
2699 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2700 if (matched)
2701 {
2702 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2703 }
2704 parsingData->PopContext(Id());
2705 }
2706 public override void Link()
2707 {
2708 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2709 a0ActionParser->SetAction(A0Action);
2710 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
2711 argNonterminalParser->SetPre(Prearg);
2712 argNonterminalParser->SetPost(Postarg);
2713 }
2714 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2715 {
2716 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2717 context->value = new PtrToIntInstruction(context->result, context->fromarg, span.lineNumber);
2718 }
2719 public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2720 {
2721 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2722 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2723 }
2724 public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2725 {
2726 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2727 if (matched)
2728 {
2729 UniquePtr<Object> fromarg_value = stack.Pop();
2730 context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
2731 }
2732 }
2733 public class Context : System.Text.Parsing.Context
2734 {
2735 public Context() : context(), result(), value(), fromarg()
2736 {
2737 }
2738 public cmsx.intermediate.Context* context;
2739 public Value* result;
2740 public Instruction* value;
2741 public Value* fromarg;
2742 }
2743 }
2744
2745 public class BinaryInstructionRule : System.Text.Parsing.RuleParser
2746 {
2747 public BinaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
2748 {
2749 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
2750 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
2751 SetValueTypeName(ToUtf32("Instruction*"));
2752 }
2753 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2754 {
2755 parsingData->PushContext(Id(), new Context());
2756 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2757 UniquePtr<Object> result_value = stack.Pop();
2758 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
2759 UniquePtr<Object> context_value = stack.Pop();
2760 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
2761 }
2762 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2763 {
2764 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2765 if (matched)
2766 {
2767 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
2768 }
2769 parsingData->PopContext(Id());
2770 }
2771 public override void Link()
2772 {
2773 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
2774 a0ActionParser->SetAction(A0Action);
2775 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
2776 a1ActionParser->SetAction(A1Action);
2777 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
2778 a2ActionParser->SetAction(A2Action);
2779 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
2780 a3ActionParser->SetAction(A3Action);
2781 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
2782 a4ActionParser->SetAction(A4Action);
2783 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
2784 a5ActionParser->SetAction(A5Action);
2785 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
2786 a6ActionParser->SetAction(A6Action);
2787 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
2788 a7ActionParser->SetAction(A7Action);
2789 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
2790 a8ActionParser->SetAction(A8Action);
2791 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
2792 a9ActionParser->SetAction(A9Action);
2793 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
2794 a10ActionParser->SetAction(A10Action);
2795 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
2796 a11ActionParser->SetAction(A11Action);
2797 NonterminalParser* addInstructionNonterminalParser = GetNonterminal(ToUtf32("AddInstruction"));
2798 addInstructionNonterminalParser->SetPre(PreAddInstruction);
2799 addInstructionNonterminalParser->SetPost(PostAddInstruction);
2800 NonterminalParser* subInstructionNonterminalParser = GetNonterminal(ToUtf32("SubInstruction"));
2801 subInstructionNonterminalParser->SetPre(PreSubInstruction);
2802 subInstructionNonterminalParser->SetPost(PostSubInstruction);
2803 NonterminalParser* mulInstructionNonterminalParser = GetNonterminal(ToUtf32("MulInstruction"));
2804 mulInstructionNonterminalParser->SetPre(PreMulInstruction);
2805 mulInstructionNonterminalParser->SetPost(PostMulInstruction);
2806 NonterminalParser* divInstructionNonterminalParser = GetNonterminal(ToUtf32("DivInstruction"));
2807 divInstructionNonterminalParser->SetPre(PreDivInstruction);
2808 divInstructionNonterminalParser->SetPost(PostDivInstruction);
2809 NonterminalParser* modInstructionNonterminalParser = GetNonterminal(ToUtf32("ModInstruction"));
2810 modInstructionNonterminalParser->SetPre(PreModInstruction);
2811 modInstructionNonterminalParser->SetPost(PostModInstruction);
2812 NonterminalParser* andInstructionNonterminalParser = GetNonterminal(ToUtf32("AndInstruction"));
2813 andInstructionNonterminalParser->SetPre(PreAndInstruction);
2814 andInstructionNonterminalParser->SetPost(PostAndInstruction);
2815 NonterminalParser* orInstructionNonterminalParser = GetNonterminal(ToUtf32("OrInstruction"));
2816 orInstructionNonterminalParser->SetPre(PreOrInstruction);
2817 orInstructionNonterminalParser->SetPost(PostOrInstruction);
2818 NonterminalParser* xorInstructionNonterminalParser = GetNonterminal(ToUtf32("XorInstruction"));
2819 xorInstructionNonterminalParser->SetPre(PreXorInstruction);
2820 xorInstructionNonterminalParser->SetPost(PostXorInstruction);
2821 NonterminalParser* shlInstructionNonterminalParser = GetNonterminal(ToUtf32("ShlInstruction"));
2822 shlInstructionNonterminalParser->SetPre(PreShlInstruction);
2823 shlInstructionNonterminalParser->SetPost(PostShlInstruction);
2824 NonterminalParser* shrInstructionNonterminalParser = GetNonterminal(ToUtf32("ShrInstruction"));
2825 shrInstructionNonterminalParser->SetPre(PreShrInstruction);
2826 shrInstructionNonterminalParser->SetPost(PostShrInstruction);
2827 NonterminalParser* equalInstructionNonterminalParser = GetNonterminal(ToUtf32("EqualInstruction"));
2828 equalInstructionNonterminalParser->SetPre(PreEqualInstruction);
2829 equalInstructionNonterminalParser->SetPost(PostEqualInstruction);
2830 NonterminalParser* lessInstructionNonterminalParser = GetNonterminal(ToUtf32("LessInstruction"));
2831 lessInstructionNonterminalParser->SetPre(PreLessInstruction);
2832 lessInstructionNonterminalParser->SetPost(PostLessInstruction);
2833 }
2834 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2835 {
2836 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2837 context->value = context->fromAddInstruction;
2838 }
2839 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2840 {
2841 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2842 context->value = context->fromSubInstruction;
2843 }
2844 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2845 {
2846 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2847 context->value = context->fromMulInstruction;
2848 }
2849 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2850 {
2851 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2852 context->value = context->fromDivInstruction;
2853 }
2854 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2855 {
2856 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2857 context->value = context->fromModInstruction;
2858 }
2859 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2860 {
2861 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2862 context->value = context->fromAndInstruction;
2863 }
2864 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2865 {
2866 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2867 context->value = context->fromOrInstruction;
2868 }
2869 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2870 {
2871 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2872 context->value = context->fromXorInstruction;
2873 }
2874 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2875 {
2876 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2877 context->value = context->fromShlInstruction;
2878 }
2879 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2880 {
2881 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2882 context->value = context->fromShrInstruction;
2883 }
2884 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2885 {
2886 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2887 context->value = context->fromEqualInstruction;
2888 }
2889 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
2890 {
2891 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2892 context->value = context->fromLessInstruction;
2893 }
2894 public void PreAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2895 {
2896 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2897 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2898 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2899 }
2900 public void PostAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2901 {
2902 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2903 if (matched)
2904 {
2905 UniquePtr<Object> fromAddInstruction_value = stack.Pop();
2906 context->fromAddInstruction = *cast<ValueObject<Instruction*>*>(fromAddInstruction_value.Get());
2907 }
2908 }
2909 public void PreSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2910 {
2911 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2912 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2913 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2914 }
2915 public void PostSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2916 {
2917 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2918 if (matched)
2919 {
2920 UniquePtr<Object> fromSubInstruction_value = stack.Pop();
2921 context->fromSubInstruction = *cast<ValueObject<Instruction*>*>(fromSubInstruction_value.Get());
2922 }
2923 }
2924 public void PreMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2925 {
2926 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2927 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2928 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2929 }
2930 public void PostMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2931 {
2932 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2933 if (matched)
2934 {
2935 UniquePtr<Object> fromMulInstruction_value = stack.Pop();
2936 context->fromMulInstruction = *cast<ValueObject<Instruction*>*>(fromMulInstruction_value.Get());
2937 }
2938 }
2939 public void PreDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2940 {
2941 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2942 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2943 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2944 }
2945 public void PostDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2946 {
2947 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2948 if (matched)
2949 {
2950 UniquePtr<Object> fromDivInstruction_value = stack.Pop();
2951 context->fromDivInstruction = *cast<ValueObject<Instruction*>*>(fromDivInstruction_value.Get());
2952 }
2953 }
2954 public void PreModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2955 {
2956 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2957 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2958 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2959 }
2960 public void PostModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2961 {
2962 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2963 if (matched)
2964 {
2965 UniquePtr<Object> fromModInstruction_value = stack.Pop();
2966 context->fromModInstruction = *cast<ValueObject<Instruction*>*>(fromModInstruction_value.Get());
2967 }
2968 }
2969 public void PreAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2970 {
2971 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2972 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2973 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2974 }
2975 public void PostAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2976 {
2977 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2978 if (matched)
2979 {
2980 UniquePtr<Object> fromAndInstruction_value = stack.Pop();
2981 context->fromAndInstruction = *cast<ValueObject<Instruction*>*>(fromAndInstruction_value.Get());
2982 }
2983 }
2984 public void PreOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
2985 {
2986 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2987 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
2988 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
2989 }
2990 public void PostOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
2991 {
2992 Context* context = cast<Context*>(parsingData->GetContext(Id()));
2993 if (matched)
2994 {
2995 UniquePtr<Object> fromOrInstruction_value = stack.Pop();
2996 context->fromOrInstruction = *cast<ValueObject<Instruction*>*>(fromOrInstruction_value.Get());
2997 }
2998 }
2999 public void PreXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3000 {
3001 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3002 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3003 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3004 }
3005 public void PostXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3006 {
3007 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3008 if (matched)
3009 {
3010 UniquePtr<Object> fromXorInstruction_value = stack.Pop();
3011 context->fromXorInstruction = *cast<ValueObject<Instruction*>*>(fromXorInstruction_value.Get());
3012 }
3013 }
3014 public void PreShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3015 {
3016 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3017 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3018 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3019 }
3020 public void PostShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3021 {
3022 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3023 if (matched)
3024 {
3025 UniquePtr<Object> fromShlInstruction_value = stack.Pop();
3026 context->fromShlInstruction = *cast<ValueObject<Instruction*>*>(fromShlInstruction_value.Get());
3027 }
3028 }
3029 public void PreShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3030 {
3031 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3032 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3033 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3034 }
3035 public void PostShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3036 {
3037 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3038 if (matched)
3039 {
3040 UniquePtr<Object> fromShrInstruction_value = stack.Pop();
3041 context->fromShrInstruction = *cast<ValueObject<Instruction*>*>(fromShrInstruction_value.Get());
3042 }
3043 }
3044 public void PreEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3045 {
3046 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3047 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3048 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3049 }
3050 public void PostEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3051 {
3052 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3053 if (matched)
3054 {
3055 UniquePtr<Object> fromEqualInstruction_value = stack.Pop();
3056 context->fromEqualInstruction = *cast<ValueObject<Instruction*>*>(fromEqualInstruction_value.Get());
3057 }
3058 }
3059 public void PreLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3060 {
3061 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3062 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3063 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
3064 }
3065 public void PostLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3066 {
3067 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3068 if (matched)
3069 {
3070 UniquePtr<Object> fromLessInstruction_value = stack.Pop();
3071 context->fromLessInstruction = *cast<ValueObject<Instruction*>*>(fromLessInstruction_value.Get());
3072 }
3073 }
3074 public class Context : System.Text.Parsing.Context
3075 {
3076 public Context() : context(), result(), value(), fromAddInstruction(), fromSubInstruction(), fromMulInstruction(), fromDivInstruction(), fromModInstruction(), fromAndInstruction(), fromOrInstruction(), fromXorInstruction(), fromShlInstruction(), fromShrInstruction(), fromEqualInstruction(), fromLessInstruction()
3077 {
3078 }
3079 public cmsx.intermediate.Context* context;
3080 public Value* result;
3081 public Instruction* value;
3082 public Instruction* fromAddInstruction;
3083 public Instruction* fromSubInstruction;
3084 public Instruction* fromMulInstruction;
3085 public Instruction* fromDivInstruction;
3086 public Instruction* fromModInstruction;
3087 public Instruction* fromAndInstruction;
3088 public Instruction* fromOrInstruction;
3089 public Instruction* fromXorInstruction;
3090 public Instruction* fromShlInstruction;
3091 public Instruction* fromShrInstruction;
3092 public Instruction* fromEqualInstruction;
3093 public Instruction* fromLessInstruction;
3094 }
3095 }
3096
3097 public class AddInstructionRule : System.Text.Parsing.RuleParser
3098 {
3099 public AddInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3100 {
3101 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3102 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3103 SetValueTypeName(ToUtf32("Instruction*"));
3104 }
3105 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3106 {
3107 parsingData->PushContext(Id(), new Context());
3108 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3109 UniquePtr<Object> result_value = stack.Pop();
3110 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3111 UniquePtr<Object> context_value = stack.Pop();
3112 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3113 }
3114 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3115 {
3116 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3117 if (matched)
3118 {
3119 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3120 }
3121 parsingData->PopContext(Id());
3122 }
3123 public override void Link()
3124 {
3125 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3126 a0ActionParser->SetAction(A0Action);
3127 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3128 leftNonterminalParser->SetPre(Preleft);
3129 leftNonterminalParser->SetPost(Postleft);
3130 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3131 rightNonterminalParser->SetPre(Preright);
3132 rightNonterminalParser->SetPost(Postright);
3133 }
3134 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3135 {
3136 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3137 context->value = new AddInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3138 }
3139 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3140 {
3141 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3142 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3143 }
3144 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3145 {
3146 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3147 if (matched)
3148 {
3149 UniquePtr<Object> fromleft_value = stack.Pop();
3150 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3151 }
3152 }
3153 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3154 {
3155 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3156 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3157 }
3158 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3159 {
3160 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3161 if (matched)
3162 {
3163 UniquePtr<Object> fromright_value = stack.Pop();
3164 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3165 }
3166 }
3167 public class Context : System.Text.Parsing.Context
3168 {
3169 public Context() : context(), result(), value(), fromleft(), fromright()
3170 {
3171 }
3172 public cmsx.intermediate.Context* context;
3173 public Value* result;
3174 public Instruction* value;
3175 public Value* fromleft;
3176 public Value* fromright;
3177 }
3178 }
3179
3180 public class SubInstructionRule : System.Text.Parsing.RuleParser
3181 {
3182 public SubInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3183 {
3184 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3185 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3186 SetValueTypeName(ToUtf32("Instruction*"));
3187 }
3188 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3189 {
3190 parsingData->PushContext(Id(), new Context());
3191 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3192 UniquePtr<Object> result_value = stack.Pop();
3193 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3194 UniquePtr<Object> context_value = stack.Pop();
3195 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3196 }
3197 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3198 {
3199 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3200 if (matched)
3201 {
3202 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3203 }
3204 parsingData->PopContext(Id());
3205 }
3206 public override void Link()
3207 {
3208 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3209 a0ActionParser->SetAction(A0Action);
3210 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3211 leftNonterminalParser->SetPre(Preleft);
3212 leftNonterminalParser->SetPost(Postleft);
3213 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3214 rightNonterminalParser->SetPre(Preright);
3215 rightNonterminalParser->SetPost(Postright);
3216 }
3217 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3218 {
3219 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3220 context->value = new SubInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3221 }
3222 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3223 {
3224 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3225 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3226 }
3227 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3228 {
3229 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3230 if (matched)
3231 {
3232 UniquePtr<Object> fromleft_value = stack.Pop();
3233 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3234 }
3235 }
3236 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3237 {
3238 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3239 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3240 }
3241 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3242 {
3243 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3244 if (matched)
3245 {
3246 UniquePtr<Object> fromright_value = stack.Pop();
3247 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3248 }
3249 }
3250 public class Context : System.Text.Parsing.Context
3251 {
3252 public Context() : context(), result(), value(), fromleft(), fromright()
3253 {
3254 }
3255 public cmsx.intermediate.Context* context;
3256 public Value* result;
3257 public Instruction* value;
3258 public Value* fromleft;
3259 public Value* fromright;
3260 }
3261 }
3262
3263 public class MulInstructionRule : System.Text.Parsing.RuleParser
3264 {
3265 public MulInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3266 {
3267 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3268 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3269 SetValueTypeName(ToUtf32("Instruction*"));
3270 }
3271 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3272 {
3273 parsingData->PushContext(Id(), new Context());
3274 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3275 UniquePtr<Object> result_value = stack.Pop();
3276 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3277 UniquePtr<Object> context_value = stack.Pop();
3278 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3279 }
3280 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3281 {
3282 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3283 if (matched)
3284 {
3285 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3286 }
3287 parsingData->PopContext(Id());
3288 }
3289 public override void Link()
3290 {
3291 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3292 a0ActionParser->SetAction(A0Action);
3293 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3294 leftNonterminalParser->SetPre(Preleft);
3295 leftNonterminalParser->SetPost(Postleft);
3296 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3297 rightNonterminalParser->SetPre(Preright);
3298 rightNonterminalParser->SetPost(Postright);
3299 }
3300 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3301 {
3302 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3303 context->value = new MulInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3304 }
3305 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3306 {
3307 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3308 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3309 }
3310 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3311 {
3312 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3313 if (matched)
3314 {
3315 UniquePtr<Object> fromleft_value = stack.Pop();
3316 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3317 }
3318 }
3319 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3320 {
3321 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3322 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3323 }
3324 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3325 {
3326 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3327 if (matched)
3328 {
3329 UniquePtr<Object> fromright_value = stack.Pop();
3330 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3331 }
3332 }
3333 public class Context : System.Text.Parsing.Context
3334 {
3335 public Context() : context(), result(), value(), fromleft(), fromright()
3336 {
3337 }
3338 public cmsx.intermediate.Context* context;
3339 public Value* result;
3340 public Instruction* value;
3341 public Value* fromleft;
3342 public Value* fromright;
3343 }
3344 }
3345
3346 public class DivInstructionRule : System.Text.Parsing.RuleParser
3347 {
3348 public DivInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3349 {
3350 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3351 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3352 SetValueTypeName(ToUtf32("Instruction*"));
3353 }
3354 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3355 {
3356 parsingData->PushContext(Id(), new Context());
3357 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3358 UniquePtr<Object> result_value = stack.Pop();
3359 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3360 UniquePtr<Object> context_value = stack.Pop();
3361 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3362 }
3363 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3364 {
3365 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3366 if (matched)
3367 {
3368 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3369 }
3370 parsingData->PopContext(Id());
3371 }
3372 public override void Link()
3373 {
3374 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3375 a0ActionParser->SetAction(A0Action);
3376 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3377 leftNonterminalParser->SetPre(Preleft);
3378 leftNonterminalParser->SetPost(Postleft);
3379 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3380 rightNonterminalParser->SetPre(Preright);
3381 rightNonterminalParser->SetPost(Postright);
3382 }
3383 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3384 {
3385 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3386 context->value = new DivInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3387 }
3388 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3389 {
3390 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3391 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3392 }
3393 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3394 {
3395 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3396 if (matched)
3397 {
3398 UniquePtr<Object> fromleft_value = stack.Pop();
3399 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3400 }
3401 }
3402 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3403 {
3404 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3405 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3406 }
3407 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3408 {
3409 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3410 if (matched)
3411 {
3412 UniquePtr<Object> fromright_value = stack.Pop();
3413 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3414 }
3415 }
3416 public class Context : System.Text.Parsing.Context
3417 {
3418 public Context() : context(), result(), value(), fromleft(), fromright()
3419 {
3420 }
3421 public cmsx.intermediate.Context* context;
3422 public Value* result;
3423 public Instruction* value;
3424 public Value* fromleft;
3425 public Value* fromright;
3426 }
3427 }
3428
3429 public class ModInstructionRule : System.Text.Parsing.RuleParser
3430 {
3431 public ModInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3432 {
3433 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3434 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3435 SetValueTypeName(ToUtf32("Instruction*"));
3436 }
3437 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3438 {
3439 parsingData->PushContext(Id(), new Context());
3440 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3441 UniquePtr<Object> result_value = stack.Pop();
3442 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3443 UniquePtr<Object> context_value = stack.Pop();
3444 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3445 }
3446 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3447 {
3448 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3449 if (matched)
3450 {
3451 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3452 }
3453 parsingData->PopContext(Id());
3454 }
3455 public override void Link()
3456 {
3457 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3458 a0ActionParser->SetAction(A0Action);
3459 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3460 leftNonterminalParser->SetPre(Preleft);
3461 leftNonterminalParser->SetPost(Postleft);
3462 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3463 rightNonterminalParser->SetPre(Preright);
3464 rightNonterminalParser->SetPost(Postright);
3465 }
3466 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3467 {
3468 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3469 context->value = new ModInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3470 }
3471 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3472 {
3473 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3474 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3475 }
3476 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3477 {
3478 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3479 if (matched)
3480 {
3481 UniquePtr<Object> fromleft_value = stack.Pop();
3482 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3483 }
3484 }
3485 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3486 {
3487 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3488 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3489 }
3490 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3491 {
3492 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3493 if (matched)
3494 {
3495 UniquePtr<Object> fromright_value = stack.Pop();
3496 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3497 }
3498 }
3499 public class Context : System.Text.Parsing.Context
3500 {
3501 public Context() : context(), result(), value(), fromleft(), fromright()
3502 {
3503 }
3504 public cmsx.intermediate.Context* context;
3505 public Value* result;
3506 public Instruction* value;
3507 public Value* fromleft;
3508 public Value* fromright;
3509 }
3510 }
3511
3512 public class AndInstructionRule : System.Text.Parsing.RuleParser
3513 {
3514 public AndInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3515 {
3516 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3517 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3518 SetValueTypeName(ToUtf32("Instruction*"));
3519 }
3520 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3521 {
3522 parsingData->PushContext(Id(), new Context());
3523 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3524 UniquePtr<Object> result_value = stack.Pop();
3525 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3526 UniquePtr<Object> context_value = stack.Pop();
3527 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3528 }
3529 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3530 {
3531 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3532 if (matched)
3533 {
3534 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3535 }
3536 parsingData->PopContext(Id());
3537 }
3538 public override void Link()
3539 {
3540 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3541 a0ActionParser->SetAction(A0Action);
3542 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3543 leftNonterminalParser->SetPre(Preleft);
3544 leftNonterminalParser->SetPost(Postleft);
3545 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3546 rightNonterminalParser->SetPre(Preright);
3547 rightNonterminalParser->SetPost(Postright);
3548 }
3549 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3550 {
3551 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3552 context->value = new AndInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3553 }
3554 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3555 {
3556 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3557 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3558 }
3559 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3560 {
3561 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3562 if (matched)
3563 {
3564 UniquePtr<Object> fromleft_value = stack.Pop();
3565 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3566 }
3567 }
3568 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3569 {
3570 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3571 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3572 }
3573 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3574 {
3575 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3576 if (matched)
3577 {
3578 UniquePtr<Object> fromright_value = stack.Pop();
3579 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3580 }
3581 }
3582 public class Context : System.Text.Parsing.Context
3583 {
3584 public Context() : context(), result(), value(), fromleft(), fromright()
3585 {
3586 }
3587 public cmsx.intermediate.Context* context;
3588 public Value* result;
3589 public Instruction* value;
3590 public Value* fromleft;
3591 public Value* fromright;
3592 }
3593 }
3594
3595 public class OrInstructionRule : System.Text.Parsing.RuleParser
3596 {
3597 public OrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3598 {
3599 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3600 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3601 SetValueTypeName(ToUtf32("Instruction*"));
3602 }
3603 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3604 {
3605 parsingData->PushContext(Id(), new Context());
3606 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3607 UniquePtr<Object> result_value = stack.Pop();
3608 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3609 UniquePtr<Object> context_value = stack.Pop();
3610 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3611 }
3612 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3613 {
3614 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3615 if (matched)
3616 {
3617 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3618 }
3619 parsingData->PopContext(Id());
3620 }
3621 public override void Link()
3622 {
3623 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3624 a0ActionParser->SetAction(A0Action);
3625 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3626 leftNonterminalParser->SetPre(Preleft);
3627 leftNonterminalParser->SetPost(Postleft);
3628 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3629 rightNonterminalParser->SetPre(Preright);
3630 rightNonterminalParser->SetPost(Postright);
3631 }
3632 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3633 {
3634 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3635 context->value = new OrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3636 }
3637 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3638 {
3639 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3640 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3641 }
3642 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3643 {
3644 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3645 if (matched)
3646 {
3647 UniquePtr<Object> fromleft_value = stack.Pop();
3648 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3649 }
3650 }
3651 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3652 {
3653 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3654 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3655 }
3656 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3657 {
3658 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3659 if (matched)
3660 {
3661 UniquePtr<Object> fromright_value = stack.Pop();
3662 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3663 }
3664 }
3665 public class Context : System.Text.Parsing.Context
3666 {
3667 public Context() : context(), result(), value(), fromleft(), fromright()
3668 {
3669 }
3670 public cmsx.intermediate.Context* context;
3671 public Value* result;
3672 public Instruction* value;
3673 public Value* fromleft;
3674 public Value* fromright;
3675 }
3676 }
3677
3678 public class XorInstructionRule : System.Text.Parsing.RuleParser
3679 {
3680 public XorInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3681 {
3682 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3683 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3684 SetValueTypeName(ToUtf32("Instruction*"));
3685 }
3686 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3687 {
3688 parsingData->PushContext(Id(), new Context());
3689 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3690 UniquePtr<Object> result_value = stack.Pop();
3691 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3692 UniquePtr<Object> context_value = stack.Pop();
3693 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3694 }
3695 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3696 {
3697 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3698 if (matched)
3699 {
3700 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3701 }
3702 parsingData->PopContext(Id());
3703 }
3704 public override void Link()
3705 {
3706 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3707 a0ActionParser->SetAction(A0Action);
3708 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3709 leftNonterminalParser->SetPre(Preleft);
3710 leftNonterminalParser->SetPost(Postleft);
3711 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3712 rightNonterminalParser->SetPre(Preright);
3713 rightNonterminalParser->SetPost(Postright);
3714 }
3715 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3716 {
3717 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3718 context->value = new XorInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3719 }
3720 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3721 {
3722 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3723 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3724 }
3725 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3726 {
3727 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3728 if (matched)
3729 {
3730 UniquePtr<Object> fromleft_value = stack.Pop();
3731 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3732 }
3733 }
3734 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3735 {
3736 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3737 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3738 }
3739 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3740 {
3741 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3742 if (matched)
3743 {
3744 UniquePtr<Object> fromright_value = stack.Pop();
3745 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3746 }
3747 }
3748 public class Context : System.Text.Parsing.Context
3749 {
3750 public Context() : context(), result(), value(), fromleft(), fromright()
3751 {
3752 }
3753 public cmsx.intermediate.Context* context;
3754 public Value* result;
3755 public Instruction* value;
3756 public Value* fromleft;
3757 public Value* fromright;
3758 }
3759 }
3760
3761 public class ShlInstructionRule : System.Text.Parsing.RuleParser
3762 {
3763 public ShlInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3764 {
3765 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3766 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3767 SetValueTypeName(ToUtf32("Instruction*"));
3768 }
3769 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3770 {
3771 parsingData->PushContext(Id(), new Context());
3772 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3773 UniquePtr<Object> result_value = stack.Pop();
3774 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3775 UniquePtr<Object> context_value = stack.Pop();
3776 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3777 }
3778 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3779 {
3780 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3781 if (matched)
3782 {
3783 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3784 }
3785 parsingData->PopContext(Id());
3786 }
3787 public override void Link()
3788 {
3789 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3790 a0ActionParser->SetAction(A0Action);
3791 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3792 leftNonterminalParser->SetPre(Preleft);
3793 leftNonterminalParser->SetPost(Postleft);
3794 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3795 rightNonterminalParser->SetPre(Preright);
3796 rightNonterminalParser->SetPost(Postright);
3797 }
3798 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3799 {
3800 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3801 context->value = new ShlInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3802 }
3803 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3804 {
3805 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3806 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3807 }
3808 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3809 {
3810 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3811 if (matched)
3812 {
3813 UniquePtr<Object> fromleft_value = stack.Pop();
3814 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3815 }
3816 }
3817 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3818 {
3819 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3820 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3821 }
3822 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3823 {
3824 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3825 if (matched)
3826 {
3827 UniquePtr<Object> fromright_value = stack.Pop();
3828 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3829 }
3830 }
3831 public class Context : System.Text.Parsing.Context
3832 {
3833 public Context() : context(), result(), value(), fromleft(), fromright()
3834 {
3835 }
3836 public cmsx.intermediate.Context* context;
3837 public Value* result;
3838 public Instruction* value;
3839 public Value* fromleft;
3840 public Value* fromright;
3841 }
3842 }
3843
3844 public class ShrInstructionRule : System.Text.Parsing.RuleParser
3845 {
3846 public ShrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3847 {
3848 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3849 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3850 SetValueTypeName(ToUtf32("Instruction*"));
3851 }
3852 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3853 {
3854 parsingData->PushContext(Id(), new Context());
3855 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3856 UniquePtr<Object> result_value = stack.Pop();
3857 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3858 UniquePtr<Object> context_value = stack.Pop();
3859 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3860 }
3861 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3862 {
3863 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3864 if (matched)
3865 {
3866 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3867 }
3868 parsingData->PopContext(Id());
3869 }
3870 public override void Link()
3871 {
3872 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3873 a0ActionParser->SetAction(A0Action);
3874 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3875 leftNonterminalParser->SetPre(Preleft);
3876 leftNonterminalParser->SetPost(Postleft);
3877 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3878 rightNonterminalParser->SetPre(Preright);
3879 rightNonterminalParser->SetPost(Postright);
3880 }
3881 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3882 {
3883 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3884 context->value = new ShrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3885 }
3886 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3887 {
3888 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3889 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3890 }
3891 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3892 {
3893 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3894 if (matched)
3895 {
3896 UniquePtr<Object> fromleft_value = stack.Pop();
3897 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3898 }
3899 }
3900 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3901 {
3902 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3903 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3904 }
3905 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3906 {
3907 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3908 if (matched)
3909 {
3910 UniquePtr<Object> fromright_value = stack.Pop();
3911 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3912 }
3913 }
3914 public class Context : System.Text.Parsing.Context
3915 {
3916 public Context() : context(), result(), value(), fromleft(), fromright()
3917 {
3918 }
3919 public cmsx.intermediate.Context* context;
3920 public Value* result;
3921 public Instruction* value;
3922 public Value* fromleft;
3923 public Value* fromright;
3924 }
3925 }
3926
3927 public class EqualInstructionRule : System.Text.Parsing.RuleParser
3928 {
3929 public EqualInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
3930 {
3931 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
3932 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
3933 SetValueTypeName(ToUtf32("Instruction*"));
3934 }
3935 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3936 {
3937 parsingData->PushContext(Id(), new Context());
3938 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3939 UniquePtr<Object> result_value = stack.Pop();
3940 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
3941 UniquePtr<Object> context_value = stack.Pop();
3942 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
3943 }
3944 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3945 {
3946 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3947 if (matched)
3948 {
3949 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
3950 }
3951 parsingData->PopContext(Id());
3952 }
3953 public override void Link()
3954 {
3955 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
3956 a0ActionParser->SetAction(A0Action);
3957 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
3958 leftNonterminalParser->SetPre(Preleft);
3959 leftNonterminalParser->SetPost(Postleft);
3960 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
3961 rightNonterminalParser->SetPre(Preright);
3962 rightNonterminalParser->SetPost(Postright);
3963 }
3964 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
3965 {
3966 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3967 context->value = new EqualInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
3968 }
3969 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3970 {
3971 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3972 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3973 }
3974 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3975 {
3976 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3977 if (matched)
3978 {
3979 UniquePtr<Object> fromleft_value = stack.Pop();
3980 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
3981 }
3982 }
3983 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
3984 {
3985 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3986 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
3987 }
3988 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
3989 {
3990 Context* context = cast<Context*>(parsingData->GetContext(Id()));
3991 if (matched)
3992 {
3993 UniquePtr<Object> fromright_value = stack.Pop();
3994 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
3995 }
3996 }
3997 public class Context : System.Text.Parsing.Context
3998 {
3999 public Context() : context(), result(), value(), fromleft(), fromright()
4000 {
4001 }
4002 public cmsx.intermediate.Context* context;
4003 public Value* result;
4004 public Instruction* value;
4005 public Value* fromleft;
4006 public Value* fromright;
4007 }
4008 }
4009
4010 public class LessInstructionRule : System.Text.Parsing.RuleParser
4011 {
4012 public LessInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4013 {
4014 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4015 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4016 SetValueTypeName(ToUtf32("Instruction*"));
4017 }
4018 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4019 {
4020 parsingData->PushContext(Id(), new Context());
4021 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4022 UniquePtr<Object> result_value = stack.Pop();
4023 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4024 UniquePtr<Object> context_value = stack.Pop();
4025 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4026 }
4027 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4028 {
4029 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4030 if (matched)
4031 {
4032 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4033 }
4034 parsingData->PopContext(Id());
4035 }
4036 public override void Link()
4037 {
4038 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4039 a0ActionParser->SetAction(A0Action);
4040 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
4041 leftNonterminalParser->SetPre(Preleft);
4042 leftNonterminalParser->SetPost(Postleft);
4043 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
4044 rightNonterminalParser->SetPre(Preright);
4045 rightNonterminalParser->SetPost(Postright);
4046 }
4047 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4048 {
4049 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4050 context->value = new LessInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
4051 }
4052 public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4053 {
4054 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4055 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4056 }
4057 public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4058 {
4059 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4060 if (matched)
4061 {
4062 UniquePtr<Object> fromleft_value = stack.Pop();
4063 context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
4064 }
4065 }
4066 public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4067 {
4068 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4069 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4070 }
4071 public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4072 {
4073 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4074 if (matched)
4075 {
4076 UniquePtr<Object> fromright_value = stack.Pop();
4077 context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
4078 }
4079 }
4080 public class Context : System.Text.Parsing.Context
4081 {
4082 public Context() : context(), result(), value(), fromleft(), fromright()
4083 {
4084 }
4085 public cmsx.intermediate.Context* context;
4086 public Value* result;
4087 public Instruction* value;
4088 public Value* fromleft;
4089 public Value* fromright;
4090 }
4091 }
4092
4093 public class ParamInstructionRule : System.Text.Parsing.RuleParser
4094 {
4095 public ParamInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4096 {
4097 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4098 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4099 SetValueTypeName(ToUtf32("Instruction*"));
4100 }
4101 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4102 {
4103 parsingData->PushContext(Id(), new Context());
4104 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4105 UniquePtr<Object> result_value = stack.Pop();
4106 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4107 UniquePtr<Object> context_value = stack.Pop();
4108 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4109 }
4110 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4111 {
4112 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4113 if (matched)
4114 {
4115 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4116 }
4117 parsingData->PopContext(Id());
4118 }
4119 public override void Link()
4120 {
4121 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4122 a0ActionParser->SetAction(A0Action);
4123 }
4124 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4125 {
4126 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4127 context->value = new ParamInstruction(context->result, span.lineNumber);
4128 }
4129 public class Context : System.Text.Parsing.Context
4130 {
4131 public Context() : context(), result(), value()
4132 {
4133 }
4134 public cmsx.intermediate.Context* context;
4135 public Value* result;
4136 public Instruction* value;
4137 }
4138 }
4139
4140 public class LocalInstructionRule : System.Text.Parsing.RuleParser
4141 {
4142 public LocalInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4143 {
4144 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4145 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4146 SetValueTypeName(ToUtf32("Instruction*"));
4147 }
4148 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4149 {
4150 parsingData->PushContext(Id(), new Context());
4151 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4152 UniquePtr<Object> result_value = stack.Pop();
4153 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4154 UniquePtr<Object> context_value = stack.Pop();
4155 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4156 }
4157 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4158 {
4159 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4160 if (matched)
4161 {
4162 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4163 }
4164 parsingData->PopContext(Id());
4165 }
4166 public override void Link()
4167 {
4168 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4169 a0ActionParser->SetAction(A0Action);
4170 NonterminalParser* localTypeNonterminalParser = GetNonterminal(ToUtf32("localType"));
4171 localTypeNonterminalParser->SetPre(PrelocalType);
4172 localTypeNonterminalParser->SetPost(PostlocalType);
4173 }
4174 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4175 {
4176 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4177 context->value = new LocalInstruction(context->result, context->fromlocalType, span.lineNumber);
4178 }
4179 public void PrelocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4180 {
4181 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4182 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4183 }
4184 public void PostlocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4185 {
4186 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4187 if (matched)
4188 {
4189 UniquePtr<Object> fromlocalType_value = stack.Pop();
4190 context->fromlocalType = *cast<ValueObject<Type*>*>(fromlocalType_value.Get());
4191 }
4192 }
4193 public class Context : System.Text.Parsing.Context
4194 {
4195 public Context() : context(), result(), value(), fromlocalType()
4196 {
4197 }
4198 public cmsx.intermediate.Context* context;
4199 public Value* result;
4200 public Instruction* value;
4201 public Type* fromlocalType;
4202 }
4203 }
4204
4205 public class LoadInstructionRule : System.Text.Parsing.RuleParser
4206 {
4207 public LoadInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4208 {
4209 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4210 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4211 SetValueTypeName(ToUtf32("Instruction*"));
4212 }
4213 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4214 {
4215 parsingData->PushContext(Id(), new Context());
4216 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4217 UniquePtr<Object> result_value = stack.Pop();
4218 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4219 UniquePtr<Object> context_value = stack.Pop();
4220 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4221 }
4222 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4223 {
4224 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4225 if (matched)
4226 {
4227 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4228 }
4229 parsingData->PopContext(Id());
4230 }
4231 public override void Link()
4232 {
4233 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4234 a0ActionParser->SetAction(A0Action);
4235 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
4236 ptrNonterminalParser->SetPre(Preptr);
4237 ptrNonterminalParser->SetPost(Postptr);
4238 }
4239 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4240 {
4241 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4242 context->value = new LoadInstruction(context->result, context->fromptr, span.lineNumber);
4243 }
4244 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4245 {
4246 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4247 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4248 }
4249 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4250 {
4251 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4252 if (matched)
4253 {
4254 UniquePtr<Object> fromptr_value = stack.Pop();
4255 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
4256 }
4257 }
4258 public class Context : System.Text.Parsing.Context
4259 {
4260 public Context() : context(), result(), value(), fromptr()
4261 {
4262 }
4263 public cmsx.intermediate.Context* context;
4264 public Value* result;
4265 public Instruction* value;
4266 public Value* fromptr;
4267 }
4268 }
4269
4270 public class ElemAddrInstructionRule : System.Text.Parsing.RuleParser
4271 {
4272 public ElemAddrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4273 {
4274 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4275 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4276 SetValueTypeName(ToUtf32("Instruction*"));
4277 }
4278 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4279 {
4280 parsingData->PushContext(Id(), new Context());
4281 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4282 UniquePtr<Object> result_value = stack.Pop();
4283 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4284 UniquePtr<Object> context_value = stack.Pop();
4285 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4286 }
4287 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4288 {
4289 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4290 if (matched)
4291 {
4292 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4293 }
4294 parsingData->PopContext(Id());
4295 }
4296 public override void Link()
4297 {
4298 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4299 a0ActionParser->SetAction(A0Action);
4300 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
4301 ptrNonterminalParser->SetPre(Preptr);
4302 ptrNonterminalParser->SetPost(Postptr);
4303 NonterminalParser* indexNonterminalParser = GetNonterminal(ToUtf32("index"));
4304 indexNonterminalParser->SetPre(Preindex);
4305 indexNonterminalParser->SetPost(Postindex);
4306 }
4307 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4308 {
4309 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4310 context->value = new ElemAddrInstruction(context->result, context->fromptr, context->fromindex, span.lineNumber);
4311 }
4312 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4313 {
4314 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4315 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4316 }
4317 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4318 {
4319 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4320 if (matched)
4321 {
4322 UniquePtr<Object> fromptr_value = stack.Pop();
4323 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
4324 }
4325 }
4326 public void Preindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4327 {
4328 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4329 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4330 }
4331 public void Postindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4332 {
4333 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4334 if (matched)
4335 {
4336 UniquePtr<Object> fromindex_value = stack.Pop();
4337 context->fromindex = *cast<ValueObject<Value*>*>(fromindex_value.Get());
4338 }
4339 }
4340 public class Context : System.Text.Parsing.Context
4341 {
4342 public Context() : context(), result(), value(), fromptr(), fromindex()
4343 {
4344 }
4345 public cmsx.intermediate.Context* context;
4346 public Value* result;
4347 public Instruction* value;
4348 public Value* fromptr;
4349 public Value* fromindex;
4350 }
4351 }
4352
4353 public class PtrOffsetInstructionRule : System.Text.Parsing.RuleParser
4354 {
4355 public PtrOffsetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4356 {
4357 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4358 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4359 SetValueTypeName(ToUtf32("Instruction*"));
4360 }
4361 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4362 {
4363 parsingData->PushContext(Id(), new Context());
4364 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4365 UniquePtr<Object> result_value = stack.Pop();
4366 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4367 UniquePtr<Object> context_value = stack.Pop();
4368 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4369 }
4370 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4371 {
4372 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4373 if (matched)
4374 {
4375 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4376 }
4377 parsingData->PopContext(Id());
4378 }
4379 public override void Link()
4380 {
4381 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4382 a0ActionParser->SetAction(A0Action);
4383 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
4384 ptrNonterminalParser->SetPre(Preptr);
4385 ptrNonterminalParser->SetPost(Postptr);
4386 NonterminalParser* offsetNonterminalParser = GetNonterminal(ToUtf32("offset"));
4387 offsetNonterminalParser->SetPre(Preoffset);
4388 offsetNonterminalParser->SetPost(Postoffset);
4389 }
4390 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4391 {
4392 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4393 context->value = new PtrOffsetInstruction(context->result, context->fromptr, context->fromoffset, span.lineNumber);
4394 }
4395 public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4396 {
4397 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4398 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4399 }
4400 public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4401 {
4402 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4403 if (matched)
4404 {
4405 UniquePtr<Object> fromptr_value = stack.Pop();
4406 context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
4407 }
4408 }
4409 public void Preoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4410 {
4411 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4412 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4413 }
4414 public void Postoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4415 {
4416 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4417 if (matched)
4418 {
4419 UniquePtr<Object> fromoffset_value = stack.Pop();
4420 context->fromoffset = *cast<ValueObject<Value*>*>(fromoffset_value.Get());
4421 }
4422 }
4423 public class Context : System.Text.Parsing.Context
4424 {
4425 public Context() : context(), result(), value(), fromptr(), fromoffset()
4426 {
4427 }
4428 public cmsx.intermediate.Context* context;
4429 public Value* result;
4430 public Instruction* value;
4431 public Value* fromptr;
4432 public Value* fromoffset;
4433 }
4434 }
4435
4436 public class PtrDiffInstructionRule : System.Text.Parsing.RuleParser
4437 {
4438 public PtrDiffInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4439 {
4440 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4441 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4442 SetValueTypeName(ToUtf32("Instruction*"));
4443 }
4444 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4445 {
4446 parsingData->PushContext(Id(), new Context());
4447 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4448 UniquePtr<Object> result_value = stack.Pop();
4449 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4450 UniquePtr<Object> context_value = stack.Pop();
4451 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4452 }
4453 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4454 {
4455 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4456 if (matched)
4457 {
4458 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4459 }
4460 parsingData->PopContext(Id());
4461 }
4462 public override void Link()
4463 {
4464 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4465 a0ActionParser->SetAction(A0Action);
4466 NonterminalParser* leftPtrNonterminalParser = GetNonterminal(ToUtf32("leftPtr"));
4467 leftPtrNonterminalParser->SetPre(PreleftPtr);
4468 leftPtrNonterminalParser->SetPost(PostleftPtr);
4469 NonterminalParser* rightPtrNonterminalParser = GetNonterminal(ToUtf32("rightPtr"));
4470 rightPtrNonterminalParser->SetPre(PrerightPtr);
4471 rightPtrNonterminalParser->SetPost(PostrightPtr);
4472 }
4473 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4474 {
4475 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4476 context->value = new PtrDiffInstruction(context->result, context->fromleftPtr, context->fromrightPtr, span.lineNumber);
4477 }
4478 public void PreleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4479 {
4480 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4481 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4482 }
4483 public void PostleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4484 {
4485 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4486 if (matched)
4487 {
4488 UniquePtr<Object> fromleftPtr_value = stack.Pop();
4489 context->fromleftPtr = *cast<ValueObject<Value*>*>(fromleftPtr_value.Get());
4490 }
4491 }
4492 public void PrerightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4493 {
4494 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4495 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4496 }
4497 public void PostrightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4498 {
4499 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4500 if (matched)
4501 {
4502 UniquePtr<Object> fromrightPtr_value = stack.Pop();
4503 context->fromrightPtr = *cast<ValueObject<Value*>*>(fromrightPtr_value.Get());
4504 }
4505 }
4506 public class Context : System.Text.Parsing.Context
4507 {
4508 public Context() : context(), result(), value(), fromleftPtr(), fromrightPtr()
4509 {
4510 }
4511 public cmsx.intermediate.Context* context;
4512 public Value* result;
4513 public Instruction* value;
4514 public Value* fromleftPtr;
4515 public Value* fromrightPtr;
4516 }
4517 }
4518
4519 public class FunctionCallInstructionRule : System.Text.Parsing.RuleParser
4520 {
4521 public FunctionCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4522 {
4523 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4524 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4525 SetValueTypeName(ToUtf32("Instruction*"));
4526 }
4527 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4528 {
4529 parsingData->PushContext(Id(), new Context());
4530 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4531 UniquePtr<Object> result_value = stack.Pop();
4532 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4533 UniquePtr<Object> context_value = stack.Pop();
4534 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4535 }
4536 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4537 {
4538 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4539 if (matched)
4540 {
4541 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4542 }
4543 parsingData->PopContext(Id());
4544 }
4545 public override void Link()
4546 {
4547 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4548 a0ActionParser->SetAction(A0Action);
4549 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
4550 functionTypeNonterminalParser->SetPre(PrefunctionType);
4551 functionTypeNonterminalParser->SetPost(PostfunctionType);
4552 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
4553 calleeNonterminalParser->SetPre(Precallee);
4554 calleeNonterminalParser->SetPost(Postcallee);
4555 }
4556 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4557 {
4558 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4559 context->value = new FunctionCallInstruction(context->result, context->fromcallee, span.lineNumber);
4560 }
4561 public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4562 {
4563 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4564 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4565 }
4566 public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4567 {
4568 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4569 if (matched)
4570 {
4571 UniquePtr<Object> fromfunctionType_value = stack.Pop();
4572 context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
4573 }
4574 }
4575 public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4576 {
4577 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4578 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4579 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
4580 }
4581 public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4582 {
4583 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4584 if (matched)
4585 {
4586 UniquePtr<Object> fromcallee_value = stack.Pop();
4587 context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
4588 }
4589 }
4590 public class Context : System.Text.Parsing.Context
4591 {
4592 public Context() : context(), result(), value(), fromfunctionType(), fromcallee()
4593 {
4594 }
4595 public cmsx.intermediate.Context* context;
4596 public Value* result;
4597 public Instruction* value;
4598 public Type* fromfunctionType;
4599 public Value* fromcallee;
4600 }
4601 }
4602
4603 public class TrapInstructionRule : System.Text.Parsing.RuleParser
4604 {
4605 public TrapInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4606 {
4607 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4608 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
4609 SetValueTypeName(ToUtf32("Instruction*"));
4610 }
4611 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4612 {
4613 parsingData->PushContext(Id(), new Context());
4614 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4615 UniquePtr<Object> result_value = stack.Pop();
4616 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
4617 UniquePtr<Object> context_value = stack.Pop();
4618 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4619 }
4620 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4621 {
4622 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4623 if (matched)
4624 {
4625 stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
4626 }
4627 parsingData->PopContext(Id());
4628 }
4629 public override void Link()
4630 {
4631 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4632 a0ActionParser->SetAction(A0Action);
4633 NonterminalParser* type1NonterminalParser = GetNonterminal(ToUtf32("type1"));
4634 type1NonterminalParser->SetPre(Pretype1);
4635 type1NonterminalParser->SetPost(Posttype1);
4636 NonterminalParser* val1NonterminalParser = GetNonterminal(ToUtf32("val1"));
4637 val1NonterminalParser->SetPre(Preval1);
4638 val1NonterminalParser->SetPost(Postval1);
4639 NonterminalParser* type2NonterminalParser = GetNonterminal(ToUtf32("type2"));
4640 type2NonterminalParser->SetPre(Pretype2);
4641 type2NonterminalParser->SetPost(Posttype2);
4642 NonterminalParser* val2NonterminalParser = GetNonterminal(ToUtf32("val2"));
4643 val2NonterminalParser->SetPre(Preval2);
4644 val2NonterminalParser->SetPost(Postval2);
4645 NonterminalParser* type3NonterminalParser = GetNonterminal(ToUtf32("type3"));
4646 type3NonterminalParser->SetPre(Pretype3);
4647 type3NonterminalParser->SetPost(Posttype3);
4648 NonterminalParser* val3NonterminalParser = GetNonterminal(ToUtf32("val3"));
4649 val3NonterminalParser->SetPre(Preval3);
4650 val3NonterminalParser->SetPost(Postval3);
4651 }
4652 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4653 {
4654 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4655 context->value = new TrapInstruction(context->result, context->fromval1, context->fromval2, context->fromval3, span.lineNumber);
4656 }
4657 public void Pretype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4658 {
4659 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4660 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4661 }
4662 public void Posttype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4663 {
4664 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4665 if (matched)
4666 {
4667 UniquePtr<Object> fromtype1_value = stack.Pop();
4668 context->fromtype1 = *cast<ValueObject<Type*>*>(fromtype1_value.Get());
4669 }
4670 }
4671 public void Preval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4672 {
4673 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4674 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4675 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype1)));
4676 }
4677 public void Postval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4678 {
4679 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4680 if (matched)
4681 {
4682 UniquePtr<Object> fromval1_value = stack.Pop();
4683 context->fromval1 = *cast<ValueObject<Value*>*>(fromval1_value.Get());
4684 }
4685 }
4686 public void Pretype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4687 {
4688 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4689 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4690 }
4691 public void Posttype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4692 {
4693 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4694 if (matched)
4695 {
4696 UniquePtr<Object> fromtype2_value = stack.Pop();
4697 context->fromtype2 = *cast<ValueObject<Type*>*>(fromtype2_value.Get());
4698 }
4699 }
4700 public void Preval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4701 {
4702 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4703 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4704 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype2)));
4705 }
4706 public void Postval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4707 {
4708 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4709 if (matched)
4710 {
4711 UniquePtr<Object> fromval2_value = stack.Pop();
4712 context->fromval2 = *cast<ValueObject<Value*>*>(fromval2_value.Get());
4713 }
4714 }
4715 public void Pretype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4716 {
4717 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4718 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4719 }
4720 public void Posttype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4721 {
4722 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4723 if (matched)
4724 {
4725 UniquePtr<Object> fromtype3_value = stack.Pop();
4726 context->fromtype3 = *cast<ValueObject<Type*>*>(fromtype3_value.Get());
4727 }
4728 }
4729 public void Preval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4730 {
4731 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4732 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4733 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype3)));
4734 }
4735 public void Postval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4736 {
4737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4738 if (matched)
4739 {
4740 UniquePtr<Object> fromval3_value = stack.Pop();
4741 context->fromval3 = *cast<ValueObject<Value*>*>(fromval3_value.Get());
4742 }
4743 }
4744 public class Context : System.Text.Parsing.Context
4745 {
4746 public Context() : context(), result(), value(), fromtype1(), fromval1(), fromtype2(), fromval2(), fromtype3(), fromval3()
4747 {
4748 }
4749 public cmsx.intermediate.Context* context;
4750 public Value* result;
4751 public Instruction* value;
4752 public Type* fromtype1;
4753 public Value* fromval1;
4754 public Type* fromtype2;
4755 public Value* fromval2;
4756 public Type* fromtype3;
4757 public Value* fromval3;
4758 }
4759 }
4760
4761 public class OperandRule : System.Text.Parsing.RuleParser
4762 {
4763 public OperandRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4764 {
4765 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4766 SetValueTypeName(ToUtf32("Value*"));
4767 }
4768 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4769 {
4770 parsingData->PushContext(Id(), new Context());
4771 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4772 UniquePtr<Object> context_value = stack.Pop();
4773 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4774 }
4775 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4776 {
4777 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4778 if (matched)
4779 {
4780 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
4781 }
4782 parsingData->PopContext(Id());
4783 }
4784 public override void Link()
4785 {
4786 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4787 a0ActionParser->SetAction(A0Action);
4788 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
4789 typeNonterminalParser->SetPre(Pretype);
4790 typeNonterminalParser->SetPost(Posttype);
4791 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
4792 valNonterminalParser->SetPre(Preval);
4793 valNonterminalParser->SetPost(Postval);
4794 }
4795 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4796 {
4797 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4798 context->value = context->fromval;
4799 }
4800 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4801 {
4802 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4803 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4804 }
4805 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4806 {
4807 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4808 if (matched)
4809 {
4810 UniquePtr<Object> fromtype_value = stack.Pop();
4811 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
4812 }
4813 }
4814 public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4815 {
4816 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4817 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4818 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
4819 }
4820 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4821 {
4822 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4823 if (matched)
4824 {
4825 UniquePtr<Object> fromval_value = stack.Pop();
4826 context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
4827 }
4828 }
4829 public class Context : System.Text.Parsing.Context
4830 {
4831 public Context() : context(), value(), fromtype(), fromval()
4832 {
4833 }
4834 public cmsx.intermediate.Context* context;
4835 public Value* value;
4836 public Type* fromtype;
4837 public Value* fromval;
4838 }
4839 }
4840
4841 public class LabelRule : System.Text.Parsing.RuleParser
4842 {
4843 public LabelRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4844 {
4845 SetValueTypeName(ToUtf32("uint"));
4846 }
4847 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4848 {
4849 parsingData->PushContext(Id(), new Context());
4850 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4851 }
4852 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4853 {
4854 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4855 if (matched)
4856 {
4857 stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
4858 }
4859 parsingData->PopContext(Id());
4860 }
4861 public override void Link()
4862 {
4863 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4864 a0ActionParser->SetAction(A0Action);
4865 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
4866 xNonterminalParser->SetPost(Postx);
4867 }
4868 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4869 {
4870 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4871 context->value = context->fromx;
4872 }
4873 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4874 {
4875 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4876 if (matched)
4877 {
4878 UniquePtr<Object> fromx_value = stack.Pop();
4879 context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
4880 }
4881 }
4882 public class Context : System.Text.Parsing.Context
4883 {
4884 public Context() : value(), fromx()
4885 {
4886 }
4887 public uint value;
4888 public uint fromx;
4889 }
4890 }
4891
4892 public class ValueRule : System.Text.Parsing.RuleParser
4893 {
4894 public ValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
4895 {
4896 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
4897 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
4898 SetValueTypeName(ToUtf32("Value*"));
4899 }
4900 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4901 {
4902 parsingData->PushContext(Id(), new Context());
4903 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4904 UniquePtr<Object> type_value = stack.Pop();
4905 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
4906 UniquePtr<Object> context_value = stack.Pop();
4907 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
4908 }
4909 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4910 {
4911 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4912 if (matched)
4913 {
4914 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
4915 }
4916 parsingData->PopContext(Id());
4917 }
4918 public override void Link()
4919 {
4920 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
4921 a0ActionParser->SetAction(A0Action);
4922 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
4923 a1ActionParser->SetAction(A1Action);
4924 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
4925 a2ActionParser->SetAction(A2Action);
4926 NonterminalParser* idValueNonterminalParser = GetNonterminal(ToUtf32("IdValue"));
4927 idValueNonterminalParser->SetPre(PreIdValue);
4928 idValueNonterminalParser->SetPost(PostIdValue);
4929 NonterminalParser* symbolValueNonterminalParser = GetNonterminal(ToUtf32("SymbolValue"));
4930 symbolValueNonterminalParser->SetPre(PreSymbolValue);
4931 symbolValueNonterminalParser->SetPost(PostSymbolValue);
4932 NonterminalParser* literalValueNonterminalParser = GetNonterminal(ToUtf32("LiteralValue"));
4933 literalValueNonterminalParser->SetPre(PreLiteralValue);
4934 literalValueNonterminalParser->SetPost(PostLiteralValue);
4935 }
4936 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4937 {
4938 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4939 context->value = context->fromIdValue;
4940 }
4941 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4942 {
4943 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4944 context->value = context->fromSymbolValue;
4945 }
4946 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
4947 {
4948 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4949 context->value = context->fromLiteralValue;
4950 }
4951 public void PreIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4952 {
4953 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4954 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4955 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
4956 }
4957 public void PostIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4958 {
4959 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4960 if (matched)
4961 {
4962 UniquePtr<Object> fromIdValue_value = stack.Pop();
4963 context->fromIdValue = *cast<ValueObject<Value*>*>(fromIdValue_value.Get());
4964 }
4965 }
4966 public void PreSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4967 {
4968 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4969 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4970 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
4971 }
4972 public void PostSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4973 {
4974 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4975 if (matched)
4976 {
4977 UniquePtr<Object> fromSymbolValue_value = stack.Pop();
4978 context->fromSymbolValue = *cast<ValueObject<Value*>*>(fromSymbolValue_value.Get());
4979 }
4980 }
4981 public void PreLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
4982 {
4983 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4984 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
4985 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
4986 }
4987 public void PostLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
4988 {
4989 Context* context = cast<Context*>(parsingData->GetContext(Id()));
4990 if (matched)
4991 {
4992 UniquePtr<Object> fromLiteralValue_value = stack.Pop();
4993 context->fromLiteralValue = *cast<ValueObject<Value*>*>(fromLiteralValue_value.Get());
4994 }
4995 }
4996 public class Context : System.Text.Parsing.Context
4997 {
4998 public Context() : context(), type(), value(), fromIdValue(), fromSymbolValue(), fromLiteralValue()
4999 {
5000 }
5001 public cmsx.intermediate.Context* context;
5002 public Type* type;
5003 public Value* value;
5004 public Value* fromIdValue;
5005 public Value* fromSymbolValue;
5006 public Value* fromLiteralValue;
5007 }
5008 }
5009
5010 public class IdValueRule : System.Text.Parsing.RuleParser
5011 {
5012 public IdValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5013 {
5014 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5015 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5016 SetValueTypeName(ToUtf32("Value*"));
5017 }
5018 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5019 {
5020 parsingData->PushContext(Id(), new Context());
5021 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5022 UniquePtr<Object> type_value = stack.Pop();
5023 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5024 UniquePtr<Object> context_value = stack.Pop();
5025 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5026 }
5027 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5028 {
5029 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5030 if (matched)
5031 {
5032 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
5033 }
5034 parsingData->PopContext(Id());
5035 }
5036 public override void Link()
5037 {
5038 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5039 a0ActionParser->SetAction(A0Action);
5040 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
5041 xNonterminalParser->SetPost(Postx);
5042 }
5043 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5044 {
5045 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5046 context->value = context->context->currentFunction->MakeIdValue(span.lineNumber, context->fromx, context->type);
5047 }
5048 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5049 {
5050 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5051 if (matched)
5052 {
5053 UniquePtr<Object> fromx_value = stack.Pop();
5054 context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
5055 }
5056 }
5057 public class Context : System.Text.Parsing.Context
5058 {
5059 public Context() : context(), type(), value(), fromx()
5060 {
5061 }
5062 public cmsx.intermediate.Context* context;
5063 public Type* type;
5064 public Value* value;
5065 public uint fromx;
5066 }
5067 }
5068
5069 public class SymbolValueRule : System.Text.Parsing.RuleParser
5070 {
5071 public SymbolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5072 {
5073 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5074 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5075 SetValueTypeName(ToUtf32("Value*"));
5076 }
5077 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5078 {
5079 parsingData->PushContext(Id(), new Context());
5080 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5081 UniquePtr<Object> type_value = stack.Pop();
5082 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5083 UniquePtr<Object> context_value = stack.Pop();
5084 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5085 }
5086 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5087 {
5088 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5089 if (matched)
5090 {
5091 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
5092 }
5093 parsingData->PopContext(Id());
5094 }
5095 public override void Link()
5096 {
5097 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5098 a0ActionParser->SetAction(A0Action);
5099 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("identifier"));
5100 identifierNonterminalParser->SetPost(Postidentifier);
5101 }
5102 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5103 {
5104 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5105 context->value = context->context->MakeSymbolValue(span.lineNumber, ToUtf8(context->fromidentifier), context->type);
5106 }
5107 public void Postidentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5108 {
5109 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5110 if (matched)
5111 {
5112 UniquePtr<Object> fromidentifier_value = stack.Pop();
5113 context->fromidentifier = *cast<ValueObject<ustring>*>(fromidentifier_value.Get());
5114 }
5115 }
5116 public class Context : System.Text.Parsing.Context
5117 {
5118 public Context() : context(), type(), value(), fromidentifier()
5119 {
5120 }
5121 public cmsx.intermediate.Context* context;
5122 public Type* type;
5123 public Value* value;
5124 public ustring fromidentifier;
5125 }
5126 }
5127
5128 public class LiteralValueRule : System.Text.Parsing.RuleParser
5129 {
5130 public LiteralValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5131 {
5132 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5133 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
5134 SetValueTypeName(ToUtf32("Value*"));
5135 }
5136 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5137 {
5138 parsingData->PushContext(Id(), new Context());
5139 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5140 UniquePtr<Object> type_value = stack.Pop();
5141 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
5142 UniquePtr<Object> context_value = stack.Pop();
5143 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5144 }
5145 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5146 {
5147 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5148 if (matched)
5149 {
5150 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
5151 }
5152 parsingData->PopContext(Id());
5153 }
5154 public override void Link()
5155 {
5156 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5157 a0ActionParser->SetAction(A0Action);
5158 }
5159 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5160 {
5161 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5162 context->value = context->context->MakeLiteralValue(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)), context->type);
5163 }
5164 public class Context : System.Text.Parsing.Context
5165 {
5166 public Context() : context(), type(), value()
5167 {
5168 }
5169 public cmsx.intermediate.Context* context;
5170 public Type* type;
5171 public Value* value;
5172 }
5173 }
5174
5175 public class TypeDeclarationRule : System.Text.Parsing.RuleParser
5176 {
5177 public TypeDeclarationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5178 {
5179 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5180 }
5181 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5182 {
5183 parsingData->PushContext(Id(), new Context());
5184 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5185 UniquePtr<Object> context_value = stack.Pop();
5186 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5187 }
5188 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5189 {
5190 parsingData->PopContext(Id());
5191 }
5192 public override void Link()
5193 {
5194 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("typeId"));
5195 typeIdNonterminalParser->SetPre(PretypeId);
5196 typeIdNonterminalParser->SetPost(PosttypeId);
5197 NonterminalParser* structureTypeNonterminalParser = GetNonterminal(ToUtf32("StructureType"));
5198 structureTypeNonterminalParser->SetPre(PreStructureType);
5199 NonterminalParser* arrayTypeNonterminalParser = GetNonterminal(ToUtf32("ArrayType"));
5200 arrayTypeNonterminalParser->SetPre(PreArrayType);
5201 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("FunctionType"));
5202 functionTypeNonterminalParser->SetPre(PreFunctionType);
5203 }
5204 public void PretypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5205 {
5206 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5207 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5208 }
5209 public void PosttypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5210 {
5211 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5212 if (matched)
5213 {
5214 UniquePtr<Object> fromtypeId_value = stack.Pop();
5215 context->fromtypeId = *cast<ValueObject<string>*>(fromtypeId_value.Get());
5216 }
5217 }
5218 public void PreStructureType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5219 {
5220 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5221 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
5222 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5223 }
5224 public void PreArrayType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5225 {
5226 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5227 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
5228 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5229 }
5230 public void PreFunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5231 {
5232 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5233 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
5234 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5235 }
5236 public class Context : System.Text.Parsing.Context
5237 {
5238 public Context() : context(), fromtypeId()
5239 {
5240 }
5241 public cmsx.intermediate.Context* context;
5242 public string fromtypeId;
5243 }
5244 }
5245
5246 public class StructureTypeRule : System.Text.Parsing.RuleParser
5247 {
5248 public StructureTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5249 {
5250 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
5251 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5252 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("memberTypeIds")));
5253 }
5254 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5255 {
5256 parsingData->PushContext(Id(), new Context());
5257 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5258 UniquePtr<Object> context_value = stack.Pop();
5259 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5260 UniquePtr<Object> typeId_value = stack.Pop();
5261 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
5262 }
5263 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5264 {
5265 parsingData->PopContext(Id());
5266 }
5267 public override void Link()
5268 {
5269 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5270 a0ActionParser->SetAction(A0Action);
5271 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5272 a1ActionParser->SetAction(A1Action);
5273 NonterminalParser* strTypeIdNonterminalParser = GetNonterminal(ToUtf32("StrTypeId"));
5274 strTypeIdNonterminalParser->SetPre(PreStrTypeId);
5275 strTypeIdNonterminalParser->SetPost(PostStrTypeId);
5276 NonterminalParser* longNonterminalParser = GetNonterminal(ToUtf32("long"));
5277 longNonterminalParser->SetPost(Postlong);
5278 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
5279 szNonterminalParser->SetPost(Postsz);
5280 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
5281 alNonterminalParser->SetPost(Postal);
5282 }
5283 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5284 {
5285 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5286 context->context->AddStructureType(context->typeId, context->memberTypeIds);
5287 }
5288 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5289 {
5290 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5291 context->memberTypeIds.Add(context->fromStrTypeId);
5292 }
5293 public void PreStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5294 {
5295 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5296 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5297 }
5298 public void PostStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5299 {
5300 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5301 if (matched)
5302 {
5303 UniquePtr<Object> fromStrTypeId_value = stack.Pop();
5304 context->fromStrTypeId = *cast<ValueObject<string>*>(fromStrTypeId_value.Get());
5305 }
5306 }
5307 public void Postlong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5308 {
5309 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5310 if (matched)
5311 {
5312 UniquePtr<Object> fromlong_value = stack.Pop();
5313 context->fromlong = *cast<ValueObject<long>*>(fromlong_value.Get());
5314 }
5315 }
5316 public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5317 {
5318 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5319 if (matched)
5320 {
5321 UniquePtr<Object> fromsz_value = stack.Pop();
5322 context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
5323 }
5324 }
5325 public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5326 {
5327 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5328 if (matched)
5329 {
5330 UniquePtr<Object> fromal_value = stack.Pop();
5331 context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
5332 }
5333 }
5334 public class Context : System.Text.Parsing.Context
5335 {
5336 public Context() : typeId(), context(), memberTypeIds(), fromStrTypeId(), fromlong(), fromsz(), fromal()
5337 {
5338 }
5339 public string typeId;
5340 public cmsx.intermediate.Context* context;
5341 public List<string> memberTypeIds;
5342 public string fromStrTypeId;
5343 public long fromlong;
5344 public long fromsz;
5345 public long fromal;
5346 }
5347 }
5348
5349 public class ArrayTypeRule : System.Text.Parsing.RuleParser
5350 {
5351 public ArrayTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5352 {
5353 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
5354 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5355 }
5356 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5357 {
5358 parsingData->PushContext(Id(), new Context());
5359 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5360 UniquePtr<Object> context_value = stack.Pop();
5361 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5362 UniquePtr<Object> typeId_value = stack.Pop();
5363 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
5364 }
5365 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5366 {
5367 parsingData->PopContext(Id());
5368 }
5369 public override void Link()
5370 {
5371 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5372 a0ActionParser->SetAction(A0Action);
5373 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
5374 sizeNonterminalParser->SetPost(Postsize);
5375 NonterminalParser* elementTypeIdNonterminalParser = GetNonterminal(ToUtf32("elementTypeId"));
5376 elementTypeIdNonterminalParser->SetPre(PreelementTypeId);
5377 elementTypeIdNonterminalParser->SetPost(PostelementTypeId);
5378 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
5379 szNonterminalParser->SetPost(Postsz);
5380 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
5381 alNonterminalParser->SetPost(Postal);
5382 }
5383 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5384 {
5385 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5386 context->context->AddArrayType(context->typeId, context->fromelementTypeId, context->fromsize);
5387 }
5388 public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5389 {
5390 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5391 if (matched)
5392 {
5393 UniquePtr<Object> fromsize_value = stack.Pop();
5394 context->fromsize = *cast<ValueObject<long>*>(fromsize_value.Get());
5395 }
5396 }
5397 public void PreelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5398 {
5399 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5400 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5401 }
5402 public void PostelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5403 {
5404 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5405 if (matched)
5406 {
5407 UniquePtr<Object> fromelementTypeId_value = stack.Pop();
5408 context->fromelementTypeId = *cast<ValueObject<string>*>(fromelementTypeId_value.Get());
5409 }
5410 }
5411 public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5412 {
5413 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5414 if (matched)
5415 {
5416 UniquePtr<Object> fromsz_value = stack.Pop();
5417 context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
5418 }
5419 }
5420 public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5421 {
5422 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5423 if (matched)
5424 {
5425 UniquePtr<Object> fromal_value = stack.Pop();
5426 context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
5427 }
5428 }
5429 public class Context : System.Text.Parsing.Context
5430 {
5431 public Context() : typeId(), context(), fromsize(), fromelementTypeId(), fromsz(), fromal()
5432 {
5433 }
5434 public string typeId;
5435 public cmsx.intermediate.Context* context;
5436 public long fromsize;
5437 public string fromelementTypeId;
5438 public long fromsz;
5439 public long fromal;
5440 }
5441 }
5442
5443 public class FunctionTypeRule : System.Text.Parsing.RuleParser
5444 {
5445 public FunctionTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5446 {
5447 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
5448 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5449 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("paramTypeIds")));
5450 }
5451 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5452 {
5453 parsingData->PushContext(Id(), new Context());
5454 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5455 UniquePtr<Object> context_value = stack.Pop();
5456 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5457 UniquePtr<Object> typeId_value = stack.Pop();
5458 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
5459 }
5460 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5461 {
5462 parsingData->PopContext(Id());
5463 }
5464 public override void Link()
5465 {
5466 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5467 a0ActionParser->SetAction(A0Action);
5468 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5469 a1ActionParser->SetAction(A1Action);
5470 NonterminalParser* returnTypeIdNonterminalParser = GetNonterminal(ToUtf32("returnTypeId"));
5471 returnTypeIdNonterminalParser->SetPre(PrereturnTypeId);
5472 returnTypeIdNonterminalParser->SetPost(PostreturnTypeId);
5473 NonterminalParser* paramTypeNonterminalParser = GetNonterminal(ToUtf32("paramType"));
5474 paramTypeNonterminalParser->SetPre(PreparamType);
5475 paramTypeNonterminalParser->SetPost(PostparamType);
5476 }
5477 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5478 {
5479 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5480 context->context->AddFunctionType(context->typeId, context->fromreturnTypeId, context->paramTypeIds);
5481 }
5482 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5483 {
5484 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5485 context->paramTypeIds.Add(context->fromparamType);
5486 }
5487 public void PrereturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5488 {
5489 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5490 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5491 }
5492 public void PostreturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5493 {
5494 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5495 if (matched)
5496 {
5497 UniquePtr<Object> fromreturnTypeId_value = stack.Pop();
5498 context->fromreturnTypeId = *cast<ValueObject<string>*>(fromreturnTypeId_value.Get());
5499 }
5500 }
5501 public void PreparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5502 {
5503 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5504 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5505 }
5506 public void PostparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5507 {
5508 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5509 if (matched)
5510 {
5511 UniquePtr<Object> fromparamType_value = stack.Pop();
5512 context->fromparamType = *cast<ValueObject<string>*>(fromparamType_value.Get());
5513 }
5514 }
5515 public class Context : System.Text.Parsing.Context
5516 {
5517 public Context() : typeId(), context(), paramTypeIds(), fromreturnTypeId(), fromparamType()
5518 {
5519 }
5520 public string typeId;
5521 public cmsx.intermediate.Context* context;
5522 public List<string> paramTypeIds;
5523 public string fromreturnTypeId;
5524 public string fromparamType;
5525 }
5526 }
5527
5528 public class StrTypeIdRule : System.Text.Parsing.RuleParser
5529 {
5530 public StrTypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5531 {
5532 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5533 SetValueTypeName(ToUtf32("string"));
5534 }
5535 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5536 {
5537 parsingData->PushContext(Id(), new Context());
5538 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5539 UniquePtr<Object> context_value = stack.Pop();
5540 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5541 }
5542 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5543 {
5544 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5545 if (matched)
5546 {
5547 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->value)));
5548 }
5549 parsingData->PopContext(Id());
5550 }
5551 public override void Link()
5552 {
5553 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5554 a0ActionParser->SetAction(A0Action);
5555 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5556 a1ActionParser->SetAction(A1Action);
5557 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
5558 a2ActionParser->SetAction(A2Action);
5559 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
5560 uintNonterminalParser->SetPost(Postuint);
5561 }
5562 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5563 {
5564 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5565 context->value = ToUtf8(ustring(matchBegin, matchEnd));
5566 }
5567 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5568 {
5569 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5570 context->value = ToUtf8(ustring(matchBegin, matchEnd));
5571 }
5572 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5573 {
5574 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5575 context->value.Append('*');
5576 context->context->AddPtrType(context->value);
5577 }
5578 public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5579 {
5580 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5581 if (matched)
5582 {
5583 UniquePtr<Object> fromuint_value = stack.Pop();
5584 context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
5585 }
5586 }
5587 public class Context : System.Text.Parsing.Context
5588 {
5589 public Context() : context(), value(), fromuint()
5590 {
5591 }
5592 public cmsx.intermediate.Context* context;
5593 public string value;
5594 public uint fromuint;
5595 }
5596 }
5597
5598 public class TypeExprRule : System.Text.Parsing.RuleParser
5599 {
5600 public TypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5601 {
5602 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5603 SetValueTypeName(ToUtf32("Type*"));
5604 }
5605 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5606 {
5607 parsingData->PushContext(Id(), new Context());
5608 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5609 UniquePtr<Object> context_value = stack.Pop();
5610 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5611 }
5612 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5613 {
5614 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5615 if (matched)
5616 {
5617 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5618 }
5619 parsingData->PopContext(Id());
5620 }
5621 public override void Link()
5622 {
5623 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5624 a0ActionParser->SetAction(A0Action);
5625 NonterminalParser* postfixTypeExprNonterminalParser = GetNonterminal(ToUtf32("PostfixTypeExpr"));
5626 postfixTypeExprNonterminalParser->SetPre(PrePostfixTypeExpr);
5627 postfixTypeExprNonterminalParser->SetPost(PostPostfixTypeExpr);
5628 }
5629 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5630 {
5631 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5632 context->value = context->fromPostfixTypeExpr;
5633 }
5634 public void PrePostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5635 {
5636 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5637 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5638 }
5639 public void PostPostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5640 {
5641 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5642 if (matched)
5643 {
5644 UniquePtr<Object> fromPostfixTypeExpr_value = stack.Pop();
5645 context->fromPostfixTypeExpr = *cast<ValueObject<Type*>*>(fromPostfixTypeExpr_value.Get());
5646 }
5647 }
5648 public class Context : System.Text.Parsing.Context
5649 {
5650 public Context() : context(), value(), fromPostfixTypeExpr()
5651 {
5652 }
5653 public cmsx.intermediate.Context* context;
5654 public Type* value;
5655 public Type* fromPostfixTypeExpr;
5656 }
5657 }
5658
5659 public class PostfixTypeExprRule : System.Text.Parsing.RuleParser
5660 {
5661 public PostfixTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5662 {
5663 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5664 SetValueTypeName(ToUtf32("Type*"));
5665 }
5666 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5667 {
5668 parsingData->PushContext(Id(), new Context());
5669 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5670 UniquePtr<Object> context_value = stack.Pop();
5671 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5672 }
5673 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5674 {
5675 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5676 if (matched)
5677 {
5678 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5679 }
5680 parsingData->PopContext(Id());
5681 }
5682 public override void Link()
5683 {
5684 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5685 a0ActionParser->SetAction(A0Action);
5686 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5687 a1ActionParser->SetAction(A1Action);
5688 NonterminalParser* primaryTypeExprNonterminalParser = GetNonterminal(ToUtf32("PrimaryTypeExpr"));
5689 primaryTypeExprNonterminalParser->SetPre(PrePrimaryTypeExpr);
5690 primaryTypeExprNonterminalParser->SetPost(PostPrimaryTypeExpr);
5691 }
5692 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5693 {
5694 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5695 context->value = context->fromPrimaryTypeExpr;
5696 }
5697 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5698 {
5699 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5700 context->value = context->context->GetPtrType(context->value);
5701 }
5702 public void PrePrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5703 {
5704 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5705 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5706 }
5707 public void PostPrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5708 {
5709 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5710 if (matched)
5711 {
5712 UniquePtr<Object> fromPrimaryTypeExpr_value = stack.Pop();
5713 context->fromPrimaryTypeExpr = *cast<ValueObject<Type*>*>(fromPrimaryTypeExpr_value.Get());
5714 }
5715 }
5716 public class Context : System.Text.Parsing.Context
5717 {
5718 public Context() : context(), value(), fromPrimaryTypeExpr()
5719 {
5720 }
5721 public cmsx.intermediate.Context* context;
5722 public Type* value;
5723 public Type* fromPrimaryTypeExpr;
5724 }
5725 }
5726
5727 public class PrimaryTypeExprRule : System.Text.Parsing.RuleParser
5728 {
5729 public PrimaryTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5730 {
5731 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5732 SetValueTypeName(ToUtf32("Type*"));
5733 }
5734 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5735 {
5736 parsingData->PushContext(Id(), new Context());
5737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5738 UniquePtr<Object> context_value = stack.Pop();
5739 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5740 }
5741 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5742 {
5743 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5744 if (matched)
5745 {
5746 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5747 }
5748 parsingData->PopContext(Id());
5749 }
5750 public override void Link()
5751 {
5752 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5753 a0ActionParser->SetAction(A0Action);
5754 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5755 a1ActionParser->SetAction(A1Action);
5756 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("TypeId"));
5757 typeIdNonterminalParser->SetPre(PreTypeId);
5758 typeIdNonterminalParser->SetPost(PostTypeId);
5759 NonterminalParser* primitiveTypeNonterminalParser = GetNonterminal(ToUtf32("PrimitiveType"));
5760 primitiveTypeNonterminalParser->SetPre(PrePrimitiveType);
5761 primitiveTypeNonterminalParser->SetPost(PostPrimitiveType);
5762 }
5763 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5764 {
5765 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5766 context->value = context->fromTypeId;
5767 }
5768 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5769 {
5770 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5771 context->value = context->fromPrimitiveType;
5772 }
5773 public void PreTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5774 {
5775 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5776 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5777 }
5778 public void PostTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5779 {
5780 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5781 if (matched)
5782 {
5783 UniquePtr<Object> fromTypeId_value = stack.Pop();
5784 context->fromTypeId = *cast<ValueObject<Type*>*>(fromTypeId_value.Get());
5785 }
5786 }
5787 public void PrePrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5788 {
5789 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5790 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
5791 }
5792 public void PostPrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5793 {
5794 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5795 if (matched)
5796 {
5797 UniquePtr<Object> fromPrimitiveType_value = stack.Pop();
5798 context->fromPrimitiveType = *cast<ValueObject<Type*>*>(fromPrimitiveType_value.Get());
5799 }
5800 }
5801 public class Context : System.Text.Parsing.Context
5802 {
5803 public Context() : context(), value(), fromTypeId(), fromPrimitiveType()
5804 {
5805 }
5806 public cmsx.intermediate.Context* context;
5807 public Type* value;
5808 public Type* fromTypeId;
5809 public Type* fromPrimitiveType;
5810 }
5811 }
5812
5813 public class TypeIdRule : System.Text.Parsing.RuleParser
5814 {
5815 public TypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5816 {
5817 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5818 SetValueTypeName(ToUtf32("Type*"));
5819 }
5820 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5821 {
5822 parsingData->PushContext(Id(), new Context());
5823 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5824 UniquePtr<Object> context_value = stack.Pop();
5825 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5826 }
5827 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5828 {
5829 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5830 if (matched)
5831 {
5832 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5833 }
5834 parsingData->PopContext(Id());
5835 }
5836 public override void Link()
5837 {
5838 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5839 a0ActionParser->SetAction(A0Action);
5840 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
5841 uintNonterminalParser->SetPost(Postuint);
5842 }
5843 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5844 {
5845 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5846 context->value = context->context->GetTypeById(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)));
5847 }
5848 public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5849 {
5850 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5851 if (matched)
5852 {
5853 UniquePtr<Object> fromuint_value = stack.Pop();
5854 context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
5855 }
5856 }
5857 public class Context : System.Text.Parsing.Context
5858 {
5859 public Context() : context(), value(), fromuint()
5860 {
5861 }
5862 public cmsx.intermediate.Context* context;
5863 public Type* value;
5864 public uint fromuint;
5865 }
5866 }
5867
5868 public class PrimitiveTypeRule : System.Text.Parsing.RuleParser
5869 {
5870 public PrimitiveTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
5871 {
5872 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
5873 SetValueTypeName(ToUtf32("Type*"));
5874 }
5875 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
5876 {
5877 parsingData->PushContext(Id(), new Context());
5878 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5879 UniquePtr<Object> context_value = stack.Pop();
5880 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
5881 }
5882 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
5883 {
5884 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5885 if (matched)
5886 {
5887 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
5888 }
5889 parsingData->PopContext(Id());
5890 }
5891 public override void Link()
5892 {
5893 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
5894 a0ActionParser->SetAction(A0Action);
5895 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
5896 a1ActionParser->SetAction(A1Action);
5897 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
5898 a2ActionParser->SetAction(A2Action);
5899 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
5900 a3ActionParser->SetAction(A3Action);
5901 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
5902 a4ActionParser->SetAction(A4Action);
5903 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
5904 a5ActionParser->SetAction(A5Action);
5905 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
5906 a6ActionParser->SetAction(A6Action);
5907 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
5908 a7ActionParser->SetAction(A7Action);
5909 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
5910 a8ActionParser->SetAction(A8Action);
5911 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
5912 a9ActionParser->SetAction(A9Action);
5913 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
5914 a10ActionParser->SetAction(A10Action);
5915 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
5916 a11ActionParser->SetAction(A11Action);
5917 NonterminalParser* voidTypeNonterminalParser = GetNonterminal(ToUtf32("VoidType"));
5918 voidTypeNonterminalParser->SetPre(PreVoidType);
5919 voidTypeNonterminalParser->SetPost(PostVoidType);
5920 NonterminalParser* boolTypeNonterminalParser = GetNonterminal(ToUtf32("BoolType"));
5921 boolTypeNonterminalParser->SetPre(PreBoolType);
5922 boolTypeNonterminalParser->SetPost(PostBoolType);
5923 NonterminalParser* sByteTypeNonterminalParser = GetNonterminal(ToUtf32("SByteType"));
5924 sByteTypeNonterminalParser->SetPre(PreSByteType);
5925 sByteTypeNonterminalParser->SetPost(PostSByteType);
5926 NonterminalParser* byteTypeNonterminalParser = GetNonterminal(ToUtf32("ByteType"));
5927 byteTypeNonterminalParser->SetPre(PreByteType);
5928 byteTypeNonterminalParser->SetPost(PostByteType);
5929 NonterminalParser* shortTypeNonterminalParser = GetNonterminal(ToUtf32("ShortType"));
5930 shortTypeNonterminalParser->SetPre(PreShortType);
5931 shortTypeNonterminalParser->SetPost(PostShortType);
5932 NonterminalParser* uShortTypeNonterminalParser = GetNonterminal(ToUtf32("UShortType"));
5933 uShortTypeNonterminalParser->SetPre(PreUShortType);
5934 uShortTypeNonterminalParser->SetPost(PostUShortType);
5935 NonterminalParser* intTypeNonterminalParser = GetNonterminal(ToUtf32("IntType"));
5936 intTypeNonterminalParser->SetPre(PreIntType);
5937 intTypeNonterminalParser->SetPost(PostIntType);
5938 NonterminalParser* uIntTypeNonterminalParser = GetNonterminal(ToUtf32("UIntType"));
5939 uIntTypeNonterminalParser->SetPre(PreUIntType);
5940 uIntTypeNonterminalParser->SetPost(PostUIntType);
5941 NonterminalParser* longTypeNonterminalParser = GetNonterminal(ToUtf32("LongType"));
5942 longTypeNonterminalParser->SetPre(PreLongType);
5943 longTypeNonterminalParser->SetPost(PostLongType);
5944 NonterminalParser* uLongTypeNonterminalParser = GetNonterminal(ToUtf32("ULongType"));
5945 uLongTypeNonterminalParser->SetPre(PreULongType);
5946 uLongTypeNonterminalParser->SetPost(PostULongType);
5947 NonterminalParser* floatTypeNonterminalParser = GetNonterminal(ToUtf32("FloatType"));
5948 floatTypeNonterminalParser->SetPre(PreFloatType);
5949 floatTypeNonterminalParser->SetPost(PostFloatType);
5950 NonterminalParser* doubleTypeNonterminalParser = GetNonterminal(ToUtf32("DoubleType"));
5951 doubleTypeNonterminalParser->SetPre(PreDoubleType);
5952 doubleTypeNonterminalParser->SetPost(PostDoubleType);
5953 }
5954 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5955 {
5956 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5957 context->value = context->fromVoidType;
5958 }
5959 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5960 {
5961 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5962 context->value = context->fromBoolType;
5963 }
5964 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5965 {
5966 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5967 context->value = context->fromSByteType;
5968 }
5969 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5970 {
5971 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5972 context->value = context->fromByteType;
5973 }
5974 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5975 {
5976 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5977 context->value = context->fromShortType;
5978 }
5979 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5980 {
5981 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5982 context->value = context->fromUShortType;
5983 }
5984 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5985 {
5986 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5987 context->value = context->fromIntType;
5988 }
5989 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5990 {
5991 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5992 context->value = context->fromUIntType;
5993 }
5994 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
5995 {
5996 Context* context = cast<Context*>(parsingData->GetContext(Id()));
5997 context->value = context->fromLongType;
5998 }
5999 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6000 {
6001 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6002 context->value = context->fromULongType;
6003 }
6004 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6005 {
6006 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6007 context->value = context->fromFloatType;
6008 }
6009 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6010 {
6011 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6012 context->value = context->fromDoubleType;
6013 }
6014 public void PreVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6015 {
6016 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6017 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6018 }
6019 public void PostVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6020 {
6021 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6022 if (matched)
6023 {
6024 UniquePtr<Object> fromVoidType_value = stack.Pop();
6025 context->fromVoidType = *cast<ValueObject<Type*>*>(fromVoidType_value.Get());
6026 }
6027 }
6028 public void PreBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6029 {
6030 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6031 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6032 }
6033 public void PostBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6034 {
6035 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6036 if (matched)
6037 {
6038 UniquePtr<Object> fromBoolType_value = stack.Pop();
6039 context->fromBoolType = *cast<ValueObject<Type*>*>(fromBoolType_value.Get());
6040 }
6041 }
6042 public void PreSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6043 {
6044 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6045 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6046 }
6047 public void PostSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6048 {
6049 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6050 if (matched)
6051 {
6052 UniquePtr<Object> fromSByteType_value = stack.Pop();
6053 context->fromSByteType = *cast<ValueObject<Type*>*>(fromSByteType_value.Get());
6054 }
6055 }
6056 public void PreByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6057 {
6058 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6059 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6060 }
6061 public void PostByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6062 {
6063 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6064 if (matched)
6065 {
6066 UniquePtr<Object> fromByteType_value = stack.Pop();
6067 context->fromByteType = *cast<ValueObject<Type*>*>(fromByteType_value.Get());
6068 }
6069 }
6070 public void PreShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6071 {
6072 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6073 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6074 }
6075 public void PostShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6076 {
6077 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6078 if (matched)
6079 {
6080 UniquePtr<Object> fromShortType_value = stack.Pop();
6081 context->fromShortType = *cast<ValueObject<Type*>*>(fromShortType_value.Get());
6082 }
6083 }
6084 public void PreUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6085 {
6086 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6087 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6088 }
6089 public void PostUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6090 {
6091 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6092 if (matched)
6093 {
6094 UniquePtr<Object> fromUShortType_value = stack.Pop();
6095 context->fromUShortType = *cast<ValueObject<Type*>*>(fromUShortType_value.Get());
6096 }
6097 }
6098 public void PreIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6099 {
6100 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6101 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6102 }
6103 public void PostIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6104 {
6105 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6106 if (matched)
6107 {
6108 UniquePtr<Object> fromIntType_value = stack.Pop();
6109 context->fromIntType = *cast<ValueObject<Type*>*>(fromIntType_value.Get());
6110 }
6111 }
6112 public void PreUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6113 {
6114 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6115 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6116 }
6117 public void PostUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6118 {
6119 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6120 if (matched)
6121 {
6122 UniquePtr<Object> fromUIntType_value = stack.Pop();
6123 context->fromUIntType = *cast<ValueObject<Type*>*>(fromUIntType_value.Get());
6124 }
6125 }
6126 public void PreLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6127 {
6128 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6129 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6130 }
6131 public void PostLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6132 {
6133 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6134 if (matched)
6135 {
6136 UniquePtr<Object> fromLongType_value = stack.Pop();
6137 context->fromLongType = *cast<ValueObject<Type*>*>(fromLongType_value.Get());
6138 }
6139 }
6140 public void PreULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6141 {
6142 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6143 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6144 }
6145 public void PostULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6146 {
6147 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6148 if (matched)
6149 {
6150 UniquePtr<Object> fromULongType_value = stack.Pop();
6151 context->fromULongType = *cast<ValueObject<Type*>*>(fromULongType_value.Get());
6152 }
6153 }
6154 public void PreFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6155 {
6156 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6157 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6158 }
6159 public void PostFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6160 {
6161 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6162 if (matched)
6163 {
6164 UniquePtr<Object> fromFloatType_value = stack.Pop();
6165 context->fromFloatType = *cast<ValueObject<Type*>*>(fromFloatType_value.Get());
6166 }
6167 }
6168 public void PreDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6169 {
6170 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6171 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6172 }
6173 public void PostDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6174 {
6175 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6176 if (matched)
6177 {
6178 UniquePtr<Object> fromDoubleType_value = stack.Pop();
6179 context->fromDoubleType = *cast<ValueObject<Type*>*>(fromDoubleType_value.Get());
6180 }
6181 }
6182 public class Context : System.Text.Parsing.Context
6183 {
6184 public Context() : context(), value(), fromVoidType(), fromBoolType(), fromSByteType(), fromByteType(), fromShortType(), fromUShortType(), fromIntType(), fromUIntType(), fromLongType(), fromULongType(), fromFloatType(), fromDoubleType()
6185 {
6186 }
6187 public cmsx.intermediate.Context* context;
6188 public Type* value;
6189 public Type* fromVoidType;
6190 public Type* fromBoolType;
6191 public Type* fromSByteType;
6192 public Type* fromByteType;
6193 public Type* fromShortType;
6194 public Type* fromUShortType;
6195 public Type* fromIntType;
6196 public Type* fromUIntType;
6197 public Type* fromLongType;
6198 public Type* fromULongType;
6199 public Type* fromFloatType;
6200 public Type* fromDoubleType;
6201 }
6202 }
6203
6204 public class VoidTypeRule : System.Text.Parsing.RuleParser
6205 {
6206 public VoidTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6207 {
6208 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6209 SetValueTypeName(ToUtf32("Type*"));
6210 }
6211 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6212 {
6213 parsingData->PushContext(Id(), new Context());
6214 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6215 UniquePtr<Object> context_value = stack.Pop();
6216 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6217 }
6218 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6219 {
6220 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6221 if (matched)
6222 {
6223 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6224 }
6225 parsingData->PopContext(Id());
6226 }
6227 public override void Link()
6228 {
6229 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6230 a0ActionParser->SetAction(A0Action);
6231 }
6232 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6233 {
6234 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6235 context->value = context->context->GetVoidType();
6236 }
6237 public class Context : System.Text.Parsing.Context
6238 {
6239 public Context() : context(), value()
6240 {
6241 }
6242 public cmsx.intermediate.Context* context;
6243 public Type* value;
6244 }
6245 }
6246
6247 public class BoolTypeRule : System.Text.Parsing.RuleParser
6248 {
6249 public BoolTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6250 {
6251 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6252 SetValueTypeName(ToUtf32("Type*"));
6253 }
6254 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6255 {
6256 parsingData->PushContext(Id(), new Context());
6257 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6258 UniquePtr<Object> context_value = stack.Pop();
6259 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6260 }
6261 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6262 {
6263 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6264 if (matched)
6265 {
6266 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6267 }
6268 parsingData->PopContext(Id());
6269 }
6270 public override void Link()
6271 {
6272 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6273 a0ActionParser->SetAction(A0Action);
6274 }
6275 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6276 {
6277 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6278 context->value = context->context->GetBoolType();
6279 }
6280 public class Context : System.Text.Parsing.Context
6281 {
6282 public Context() : context(), value()
6283 {
6284 }
6285 public cmsx.intermediate.Context* context;
6286 public Type* value;
6287 }
6288 }
6289
6290 public class SByteTypeRule : System.Text.Parsing.RuleParser
6291 {
6292 public SByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6293 {
6294 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6295 SetValueTypeName(ToUtf32("Type*"));
6296 }
6297 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6298 {
6299 parsingData->PushContext(Id(), new Context());
6300 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6301 UniquePtr<Object> context_value = stack.Pop();
6302 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6303 }
6304 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6305 {
6306 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6307 if (matched)
6308 {
6309 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6310 }
6311 parsingData->PopContext(Id());
6312 }
6313 public override void Link()
6314 {
6315 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6316 a0ActionParser->SetAction(A0Action);
6317 }
6318 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6319 {
6320 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6321 context->value = context->context->GetSByteType();
6322 }
6323 public class Context : System.Text.Parsing.Context
6324 {
6325 public Context() : context(), value()
6326 {
6327 }
6328 public cmsx.intermediate.Context* context;
6329 public Type* value;
6330 }
6331 }
6332
6333 public class ByteTypeRule : System.Text.Parsing.RuleParser
6334 {
6335 public ByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6336 {
6337 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6338 SetValueTypeName(ToUtf32("Type*"));
6339 }
6340 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6341 {
6342 parsingData->PushContext(Id(), new Context());
6343 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6344 UniquePtr<Object> context_value = stack.Pop();
6345 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6346 }
6347 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6348 {
6349 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6350 if (matched)
6351 {
6352 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6353 }
6354 parsingData->PopContext(Id());
6355 }
6356 public override void Link()
6357 {
6358 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6359 a0ActionParser->SetAction(A0Action);
6360 }
6361 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6362 {
6363 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6364 context->value = context->context->GetByteType();
6365 }
6366 public class Context : System.Text.Parsing.Context
6367 {
6368 public Context() : context(), value()
6369 {
6370 }
6371 public cmsx.intermediate.Context* context;
6372 public Type* value;
6373 }
6374 }
6375
6376 public class ShortTypeRule : System.Text.Parsing.RuleParser
6377 {
6378 public ShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6379 {
6380 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6381 SetValueTypeName(ToUtf32("Type*"));
6382 }
6383 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6384 {
6385 parsingData->PushContext(Id(), new Context());
6386 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6387 UniquePtr<Object> context_value = stack.Pop();
6388 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6389 }
6390 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6391 {
6392 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6393 if (matched)
6394 {
6395 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6396 }
6397 parsingData->PopContext(Id());
6398 }
6399 public override void Link()
6400 {
6401 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6402 a0ActionParser->SetAction(A0Action);
6403 }
6404 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6405 {
6406 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6407 context->value = context->context->GetShortType();
6408 }
6409 public class Context : System.Text.Parsing.Context
6410 {
6411 public Context() : context(), value()
6412 {
6413 }
6414 public cmsx.intermediate.Context* context;
6415 public Type* value;
6416 }
6417 }
6418
6419 public class UShortTypeRule : System.Text.Parsing.RuleParser
6420 {
6421 public UShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6422 {
6423 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6424 SetValueTypeName(ToUtf32("Type*"));
6425 }
6426 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6427 {
6428 parsingData->PushContext(Id(), new Context());
6429 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6430 UniquePtr<Object> context_value = stack.Pop();
6431 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6432 }
6433 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6434 {
6435 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6436 if (matched)
6437 {
6438 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6439 }
6440 parsingData->PopContext(Id());
6441 }
6442 public override void Link()
6443 {
6444 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6445 a0ActionParser->SetAction(A0Action);
6446 }
6447 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6448 {
6449 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6450 context->value = context->context->GetUShortType();
6451 }
6452 public class Context : System.Text.Parsing.Context
6453 {
6454 public Context() : context(), value()
6455 {
6456 }
6457 public cmsx.intermediate.Context* context;
6458 public Type* value;
6459 }
6460 }
6461
6462 public class IntTypeRule : System.Text.Parsing.RuleParser
6463 {
6464 public IntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6465 {
6466 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6467 SetValueTypeName(ToUtf32("Type*"));
6468 }
6469 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6470 {
6471 parsingData->PushContext(Id(), new Context());
6472 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6473 UniquePtr<Object> context_value = stack.Pop();
6474 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6475 }
6476 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6477 {
6478 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6479 if (matched)
6480 {
6481 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6482 }
6483 parsingData->PopContext(Id());
6484 }
6485 public override void Link()
6486 {
6487 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6488 a0ActionParser->SetAction(A0Action);
6489 }
6490 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6491 {
6492 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6493 context->value = context->context->GetIntType();
6494 }
6495 public class Context : System.Text.Parsing.Context
6496 {
6497 public Context() : context(), value()
6498 {
6499 }
6500 public cmsx.intermediate.Context* context;
6501 public Type* value;
6502 }
6503 }
6504
6505 public class UIntTypeRule : System.Text.Parsing.RuleParser
6506 {
6507 public UIntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6508 {
6509 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6510 SetValueTypeName(ToUtf32("Type*"));
6511 }
6512 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6513 {
6514 parsingData->PushContext(Id(), new Context());
6515 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6516 UniquePtr<Object> context_value = stack.Pop();
6517 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6518 }
6519 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6520 {
6521 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6522 if (matched)
6523 {
6524 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6525 }
6526 parsingData->PopContext(Id());
6527 }
6528 public override void Link()
6529 {
6530 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6531 a0ActionParser->SetAction(A0Action);
6532 }
6533 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6534 {
6535 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6536 context->value = context->context->GetUIntType();
6537 }
6538 public class Context : System.Text.Parsing.Context
6539 {
6540 public Context() : context(), value()
6541 {
6542 }
6543 public cmsx.intermediate.Context* context;
6544 public Type* value;
6545 }
6546 }
6547
6548 public class LongTypeRule : System.Text.Parsing.RuleParser
6549 {
6550 public LongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6551 {
6552 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6553 SetValueTypeName(ToUtf32("Type*"));
6554 }
6555 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6556 {
6557 parsingData->PushContext(Id(), new Context());
6558 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6559 UniquePtr<Object> context_value = stack.Pop();
6560 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6561 }
6562 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6563 {
6564 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6565 if (matched)
6566 {
6567 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6568 }
6569 parsingData->PopContext(Id());
6570 }
6571 public override void Link()
6572 {
6573 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6574 a0ActionParser->SetAction(A0Action);
6575 }
6576 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6577 {
6578 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6579 context->value = context->context->GetLongType();
6580 }
6581 public class Context : System.Text.Parsing.Context
6582 {
6583 public Context() : context(), value()
6584 {
6585 }
6586 public cmsx.intermediate.Context* context;
6587 public Type* value;
6588 }
6589 }
6590
6591 public class ULongTypeRule : System.Text.Parsing.RuleParser
6592 {
6593 public ULongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6594 {
6595 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6596 SetValueTypeName(ToUtf32("Type*"));
6597 }
6598 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6599 {
6600 parsingData->PushContext(Id(), new Context());
6601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6602 UniquePtr<Object> context_value = stack.Pop();
6603 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6604 }
6605 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6606 {
6607 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6608 if (matched)
6609 {
6610 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6611 }
6612 parsingData->PopContext(Id());
6613 }
6614 public override void Link()
6615 {
6616 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6617 a0ActionParser->SetAction(A0Action);
6618 }
6619 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6620 {
6621 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6622 context->value = context->context->GetULongType();
6623 }
6624 public class Context : System.Text.Parsing.Context
6625 {
6626 public Context() : context(), value()
6627 {
6628 }
6629 public cmsx.intermediate.Context* context;
6630 public Type* value;
6631 }
6632 }
6633
6634 public class FloatTypeRule : System.Text.Parsing.RuleParser
6635 {
6636 public FloatTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6637 {
6638 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6639 SetValueTypeName(ToUtf32("Type*"));
6640 }
6641 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6642 {
6643 parsingData->PushContext(Id(), new Context());
6644 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6645 UniquePtr<Object> context_value = stack.Pop();
6646 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6647 }
6648 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6649 {
6650 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6651 if (matched)
6652 {
6653 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6654 }
6655 parsingData->PopContext(Id());
6656 }
6657 public override void Link()
6658 {
6659 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6660 a0ActionParser->SetAction(A0Action);
6661 }
6662 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6663 {
6664 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6665 context->value = context->context->GetFloatType();
6666 }
6667 public class Context : System.Text.Parsing.Context
6668 {
6669 public Context() : context(), value()
6670 {
6671 }
6672 public cmsx.intermediate.Context* context;
6673 public Type* value;
6674 }
6675 }
6676
6677 public class DoubleTypeRule : System.Text.Parsing.RuleParser
6678 {
6679 public DoubleTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6680 {
6681 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6682 SetValueTypeName(ToUtf32("Type*"));
6683 }
6684 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6685 {
6686 parsingData->PushContext(Id(), new Context());
6687 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6688 UniquePtr<Object> context_value = stack.Pop();
6689 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6690 }
6691 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6692 {
6693 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6694 if (matched)
6695 {
6696 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
6697 }
6698 parsingData->PopContext(Id());
6699 }
6700 public override void Link()
6701 {
6702 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6703 a0ActionParser->SetAction(A0Action);
6704 }
6705 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6706 {
6707 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6708 context->value = context->context->GetDoubleType();
6709 }
6710 public class Context : System.Text.Parsing.Context
6711 {
6712 public Context() : context(), value()
6713 {
6714 }
6715 public cmsx.intermediate.Context* context;
6716 public Type* value;
6717 }
6718 }
6719
6720 public class DataDefinitionRule : System.Text.Parsing.RuleParser
6721 {
6722 public DataDefinitionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6723 {
6724 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6725 }
6726 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6727 {
6728 parsingData->PushContext(Id(), new Context());
6729 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6730 UniquePtr<Object> context_value = stack.Pop();
6731 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6732 }
6733 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6734 {
6735 parsingData->PopContext(Id());
6736 }
6737 public override void Link()
6738 {
6739 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6740 a0ActionParser->SetAction(A0Action);
6741 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
6742 a1ActionParser->SetAction(A1Action);
6743 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
6744 typeNonterminalParser->SetPre(Pretype);
6745 typeNonterminalParser->SetPost(Posttype);
6746 NonterminalParser* nameNonterminalParser = GetNonterminal(ToUtf32("name"));
6747 nameNonterminalParser->SetPost(Postname);
6748 NonterminalParser* constantNonterminalParser = GetNonterminal(ToUtf32("Constant"));
6749 constantNonterminalParser->SetPre(PreConstant);
6750 constantNonterminalParser->SetPost(PostConstant);
6751 }
6752 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6753 {
6754 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6755 context->context->AddDataDefinition(context->fromtype, ToUtf8(context->fromname), cast<ConstantValue*>(null));
6756 }
6757 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6758 {
6759 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6760 context->context->AddDataDefinition(context->fromtype, ToUtf8(context->fromname), context->fromConstant);
6761 }
6762 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6763 {
6764 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6765 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6766 }
6767 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6768 {
6769 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6770 if (matched)
6771 {
6772 UniquePtr<Object> fromtype_value = stack.Pop();
6773 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
6774 }
6775 }
6776 public void Postname(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6777 {
6778 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6779 if (matched)
6780 {
6781 UniquePtr<Object> fromname_value = stack.Pop();
6782 context->fromname = *cast<ValueObject<ustring>*>(fromname_value.Get());
6783 }
6784 }
6785 public void PreConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6786 {
6787 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6788 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6789 }
6790 public void PostConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6791 {
6792 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6793 if (matched)
6794 {
6795 UniquePtr<Object> fromConstant_value = stack.Pop();
6796 context->fromConstant = *cast<ValueObject<ConstantValue*>*>(fromConstant_value.Get());
6797 }
6798 }
6799 public class Context : System.Text.Parsing.Context
6800 {
6801 public Context() : context(), fromtype(), fromname(), fromConstant()
6802 {
6803 }
6804 public cmsx.intermediate.Context* context;
6805 public Type* fromtype;
6806 public ustring fromname;
6807 public ConstantValue* fromConstant;
6808 }
6809 }
6810
6811 public class ConstantRule : System.Text.Parsing.RuleParser
6812 {
6813 public ConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
6814 {
6815 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
6816 SetValueTypeName(ToUtf32("ConstantValue*"));
6817 }
6818 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6819 {
6820 parsingData->PushContext(Id(), new Context());
6821 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6822 UniquePtr<Object> context_value = stack.Pop();
6823 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
6824 }
6825 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6826 {
6827 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6828 if (matched)
6829 {
6830 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
6831 }
6832 parsingData->PopContext(Id());
6833 }
6834 public override void Link()
6835 {
6836 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
6837 a0ActionParser->SetAction(A0Action);
6838 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
6839 a1ActionParser->SetAction(A1Action);
6840 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
6841 a2ActionParser->SetAction(A2Action);
6842 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
6843 a3ActionParser->SetAction(A3Action);
6844 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
6845 a4ActionParser->SetAction(A4Action);
6846 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
6847 a5ActionParser->SetAction(A5Action);
6848 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
6849 a6ActionParser->SetAction(A6Action);
6850 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
6851 a7ActionParser->SetAction(A7Action);
6852 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
6853 a8ActionParser->SetAction(A8Action);
6854 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
6855 a9ActionParser->SetAction(A9Action);
6856 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
6857 a10ActionParser->SetAction(A10Action);
6858 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
6859 a11ActionParser->SetAction(A11Action);
6860 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
6861 a12ActionParser->SetAction(A12Action);
6862 ActionParser* a13ActionParser = GetAction(ToUtf32("A13"));
6863 a13ActionParser->SetAction(A13Action);
6864 NonterminalParser* boolConstantNonterminalParser = GetNonterminal(ToUtf32("BoolConstant"));
6865 boolConstantNonterminalParser->SetPre(PreBoolConstant);
6866 boolConstantNonterminalParser->SetPost(PostBoolConstant);
6867 NonterminalParser* sByteConstantNonterminalParser = GetNonterminal(ToUtf32("SByteConstant"));
6868 sByteConstantNonterminalParser->SetPre(PreSByteConstant);
6869 sByteConstantNonterminalParser->SetPost(PostSByteConstant);
6870 NonterminalParser* byteConstantNonterminalParser = GetNonterminal(ToUtf32("ByteConstant"));
6871 byteConstantNonterminalParser->SetPre(PreByteConstant);
6872 byteConstantNonterminalParser->SetPost(PostByteConstant);
6873 NonterminalParser* shortConstantNonterminalParser = GetNonterminal(ToUtf32("ShortConstant"));
6874 shortConstantNonterminalParser->SetPre(PreShortConstant);
6875 shortConstantNonterminalParser->SetPost(PostShortConstant);
6876 NonterminalParser* uShortConstantNonterminalParser = GetNonterminal(ToUtf32("UShortConstant"));
6877 uShortConstantNonterminalParser->SetPre(PreUShortConstant);
6878 uShortConstantNonterminalParser->SetPost(PostUShortConstant);
6879 NonterminalParser* intConstantNonterminalParser = GetNonterminal(ToUtf32("IntConstant"));
6880 intConstantNonterminalParser->SetPre(PreIntConstant);
6881 intConstantNonterminalParser->SetPost(PostIntConstant);
6882 NonterminalParser* uIntConstantNonterminalParser = GetNonterminal(ToUtf32("UIntConstant"));
6883 uIntConstantNonterminalParser->SetPre(PreUIntConstant);
6884 uIntConstantNonterminalParser->SetPost(PostUIntConstant);
6885 NonterminalParser* longConstantNonterminalParser = GetNonterminal(ToUtf32("LongConstant"));
6886 longConstantNonterminalParser->SetPre(PreLongConstant);
6887 longConstantNonterminalParser->SetPost(PostLongConstant);
6888 NonterminalParser* uLongConstantNonterminalParser = GetNonterminal(ToUtf32("ULongConstant"));
6889 uLongConstantNonterminalParser->SetPre(PreULongConstant);
6890 uLongConstantNonterminalParser->SetPost(PostULongConstant);
6891 NonterminalParser* floatConstantNonterminalParser = GetNonterminal(ToUtf32("FloatConstant"));
6892 floatConstantNonterminalParser->SetPre(PreFloatConstant);
6893 floatConstantNonterminalParser->SetPost(PostFloatConstant);
6894 NonterminalParser* doubleConstantNonterminalParser = GetNonterminal(ToUtf32("DoubleConstant"));
6895 doubleConstantNonterminalParser->SetPre(PreDoubleConstant);
6896 doubleConstantNonterminalParser->SetPost(PostDoubleConstant);
6897 NonterminalParser* ptrConstantNonterminalParser = GetNonterminal(ToUtf32("PtrConstant"));
6898 ptrConstantNonterminalParser->SetPre(PrePtrConstant);
6899 ptrConstantNonterminalParser->SetPost(PostPtrConstant);
6900 NonterminalParser* arrayConstantNonterminalParser = GetNonterminal(ToUtf32("ArrayConstant"));
6901 arrayConstantNonterminalParser->SetPre(PreArrayConstant);
6902 arrayConstantNonterminalParser->SetPost(PostArrayConstant);
6903 NonterminalParser* structureConstantNonterminalParser = GetNonterminal(ToUtf32("StructureConstant"));
6904 structureConstantNonterminalParser->SetPre(PreStructureConstant);
6905 structureConstantNonterminalParser->SetPost(PostStructureConstant);
6906 }
6907 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6908 {
6909 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6910 context->value = context->fromBoolConstant;
6911 }
6912 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6913 {
6914 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6915 context->value = context->fromSByteConstant;
6916 }
6917 public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6918 {
6919 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6920 context->value = context->fromByteConstant;
6921 }
6922 public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6923 {
6924 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6925 context->value = context->fromShortConstant;
6926 }
6927 public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6928 {
6929 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6930 context->value = context->fromUShortConstant;
6931 }
6932 public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6933 {
6934 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6935 context->value = context->fromIntConstant;
6936 }
6937 public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6938 {
6939 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6940 context->value = context->fromUIntConstant;
6941 }
6942 public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6943 {
6944 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6945 context->value = context->fromLongConstant;
6946 }
6947 public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6948 {
6949 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6950 context->value = context->fromULongConstant;
6951 }
6952 public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6953 {
6954 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6955 context->value = context->fromFloatConstant;
6956 }
6957 public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6958 {
6959 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6960 context->value = context->fromDoubleConstant;
6961 }
6962 public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6963 {
6964 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6965 context->value = context->fromPtrConstant;
6966 }
6967 public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6968 {
6969 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6970 context->value = context->fromArrayConstant;
6971 }
6972 public void A13Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
6973 {
6974 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6975 context->value = context->fromStructureConstant;
6976 }
6977 public void PreBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6978 {
6979 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6980 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6981 }
6982 public void PostBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6983 {
6984 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6985 if (matched)
6986 {
6987 UniquePtr<Object> fromBoolConstant_value = stack.Pop();
6988 context->fromBoolConstant = *cast<ValueObject<ConstantValue*>*>(fromBoolConstant_value.Get());
6989 }
6990 }
6991 public void PreSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
6992 {
6993 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6994 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
6995 }
6996 public void PostSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
6997 {
6998 Context* context = cast<Context*>(parsingData->GetContext(Id()));
6999 if (matched)
7000 {
7001 UniquePtr<Object> fromSByteConstant_value = stack.Pop();
7002 context->fromSByteConstant = *cast<ValueObject<ConstantValue*>*>(fromSByteConstant_value.Get());
7003 }
7004 }
7005 public void PreByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7006 {
7007 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7008 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7009 }
7010 public void PostByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7011 {
7012 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7013 if (matched)
7014 {
7015 UniquePtr<Object> fromByteConstant_value = stack.Pop();
7016 context->fromByteConstant = *cast<ValueObject<ConstantValue*>*>(fromByteConstant_value.Get());
7017 }
7018 }
7019 public void PreShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7020 {
7021 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7022 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7023 }
7024 public void PostShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7025 {
7026 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7027 if (matched)
7028 {
7029 UniquePtr<Object> fromShortConstant_value = stack.Pop();
7030 context->fromShortConstant = *cast<ValueObject<ConstantValue*>*>(fromShortConstant_value.Get());
7031 }
7032 }
7033 public void PreUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7034 {
7035 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7036 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7037 }
7038 public void PostUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7039 {
7040 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7041 if (matched)
7042 {
7043 UniquePtr<Object> fromUShortConstant_value = stack.Pop();
7044 context->fromUShortConstant = *cast<ValueObject<ConstantValue*>*>(fromUShortConstant_value.Get());
7045 }
7046 }
7047 public void PreIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7048 {
7049 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7050 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7051 }
7052 public void PostIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7053 {
7054 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7055 if (matched)
7056 {
7057 UniquePtr<Object> fromIntConstant_value = stack.Pop();
7058 context->fromIntConstant = *cast<ValueObject<ConstantValue*>*>(fromIntConstant_value.Get());
7059 }
7060 }
7061 public void PreUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7062 {
7063 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7064 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7065 }
7066 public void PostUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7067 {
7068 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7069 if (matched)
7070 {
7071 UniquePtr<Object> fromUIntConstant_value = stack.Pop();
7072 context->fromUIntConstant = *cast<ValueObject<ConstantValue*>*>(fromUIntConstant_value.Get());
7073 }
7074 }
7075 public void PreLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7076 {
7077 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7078 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7079 }
7080 public void PostLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7081 {
7082 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7083 if (matched)
7084 {
7085 UniquePtr<Object> fromLongConstant_value = stack.Pop();
7086 context->fromLongConstant = *cast<ValueObject<ConstantValue*>*>(fromLongConstant_value.Get());
7087 }
7088 }
7089 public void PreULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7090 {
7091 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7092 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7093 }
7094 public void PostULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7095 {
7096 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7097 if (matched)
7098 {
7099 UniquePtr<Object> fromULongConstant_value = stack.Pop();
7100 context->fromULongConstant = *cast<ValueObject<ConstantValue*>*>(fromULongConstant_value.Get());
7101 }
7102 }
7103 public void PreFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7104 {
7105 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7106 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7107 }
7108 public void PostFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7109 {
7110 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7111 if (matched)
7112 {
7113 UniquePtr<Object> fromFloatConstant_value = stack.Pop();
7114 context->fromFloatConstant = *cast<ValueObject<ConstantValue*>*>(fromFloatConstant_value.Get());
7115 }
7116 }
7117 public void PreDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7118 {
7119 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7120 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7121 }
7122 public void PostDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7123 {
7124 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7125 if (matched)
7126 {
7127 UniquePtr<Object> fromDoubleConstant_value = stack.Pop();
7128 context->fromDoubleConstant = *cast<ValueObject<ConstantValue*>*>(fromDoubleConstant_value.Get());
7129 }
7130 }
7131 public void PrePtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7132 {
7133 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7134 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7135 }
7136 public void PostPtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7137 {
7138 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7139 if (matched)
7140 {
7141 UniquePtr<Object> fromPtrConstant_value = stack.Pop();
7142 context->fromPtrConstant = *cast<ValueObject<ConstantValue*>*>(fromPtrConstant_value.Get());
7143 }
7144 }
7145 public void PreArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7146 {
7147 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7148 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7149 }
7150 public void PostArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7151 {
7152 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7153 if (matched)
7154 {
7155 UniquePtr<Object> fromArrayConstant_value = stack.Pop();
7156 context->fromArrayConstant = *cast<ValueObject<ArrayValue*>*>(fromArrayConstant_value.Get());
7157 }
7158 }
7159 public void PreStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7160 {
7161 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7162 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7163 }
7164 public void PostStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7165 {
7166 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7167 if (matched)
7168 {
7169 UniquePtr<Object> fromStructureConstant_value = stack.Pop();
7170 context->fromStructureConstant = *cast<ValueObject<StructureValue*>*>(fromStructureConstant_value.Get());
7171 }
7172 }
7173 public class Context : System.Text.Parsing.Context
7174 {
7175 public Context() : context(), value(), fromBoolConstant(), fromSByteConstant(), fromByteConstant(), fromShortConstant(), fromUShortConstant(), fromIntConstant(), fromUIntConstant(), fromLongConstant(), fromULongConstant(), fromFloatConstant(), fromDoubleConstant(), fromPtrConstant(), fromArrayConstant(), fromStructureConstant()
7176 {
7177 }
7178 public cmsx.intermediate.Context* context;
7179 public ConstantValue* value;
7180 public ConstantValue* fromBoolConstant;
7181 public ConstantValue* fromSByteConstant;
7182 public ConstantValue* fromByteConstant;
7183 public ConstantValue* fromShortConstant;
7184 public ConstantValue* fromUShortConstant;
7185 public ConstantValue* fromIntConstant;
7186 public ConstantValue* fromUIntConstant;
7187 public ConstantValue* fromLongConstant;
7188 public ConstantValue* fromULongConstant;
7189 public ConstantValue* fromFloatConstant;
7190 public ConstantValue* fromDoubleConstant;
7191 public ConstantValue* fromPtrConstant;
7192 public ArrayValue* fromArrayConstant;
7193 public StructureValue* fromStructureConstant;
7194 }
7195 }
7196
7197 public class BoolConstantRule : System.Text.Parsing.RuleParser
7198 {
7199 public BoolConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7200 {
7201 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7202 SetValueTypeName(ToUtf32("ConstantValue*"));
7203 }
7204 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7205 {
7206 parsingData->PushContext(Id(), new Context());
7207 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7208 UniquePtr<Object> context_value = stack.Pop();
7209 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7210 }
7211 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7212 {
7213 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7214 if (matched)
7215 {
7216 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7217 }
7218 parsingData->PopContext(Id());
7219 }
7220 public override void Link()
7221 {
7222 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7223 a0ActionParser->SetAction(A0Action);
7224 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7225 typeNonterminalParser->SetPre(Pretype);
7226 typeNonterminalParser->SetPost(Posttype);
7227 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7228 valNonterminalParser->SetPost(Postval);
7229 }
7230 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7231 {
7232 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7233 context->value = cast<BoolType*>(context->fromtype)->MakeBoolValue(context->fromval);
7234 }
7235 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7236 {
7237 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7238 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7239 }
7240 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7241 {
7242 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7243 if (matched)
7244 {
7245 UniquePtr<Object> fromtype_value = stack.Pop();
7246 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7247 }
7248 }
7249 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7250 {
7251 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7252 if (matched)
7253 {
7254 UniquePtr<Object> fromval_value = stack.Pop();
7255 context->fromval = *cast<ValueObject<bool>*>(fromval_value.Get());
7256 }
7257 }
7258 public class Context : System.Text.Parsing.Context
7259 {
7260 public Context() : context(), value(), fromtype(), fromval()
7261 {
7262 }
7263 public cmsx.intermediate.Context* context;
7264 public ConstantValue* value;
7265 public Type* fromtype;
7266 public bool fromval;
7267 }
7268 }
7269
7270 public class BoolValueRule : System.Text.Parsing.RuleParser
7271 {
7272 public BoolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7273 {
7274 SetValueTypeName(ToUtf32("bool"));
7275 }
7276 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7277 {
7278 parsingData->PushContext(Id(), new Context());
7279 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7280 }
7281 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7282 {
7283 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7284 if (matched)
7285 {
7286 stack.Push(UniquePtr<Object>(new ValueObject<bool>(context->value)));
7287 }
7288 parsingData->PopContext(Id());
7289 }
7290 public override void Link()
7291 {
7292 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7293 a0ActionParser->SetAction(A0Action);
7294 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7295 xNonterminalParser->SetPost(Postx);
7296 }
7297 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7298 {
7299 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7300 context->value = context->fromx;
7301 }
7302 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7303 {
7304 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7305 if (matched)
7306 {
7307 UniquePtr<Object> fromx_value = stack.Pop();
7308 context->fromx = *cast<ValueObject<bool>*>(fromx_value.Get());
7309 }
7310 }
7311 public class Context : System.Text.Parsing.Context
7312 {
7313 public Context() : value(), fromx()
7314 {
7315 }
7316 public bool value;
7317 public bool fromx;
7318 }
7319 }
7320
7321 public class SByteConstantRule : System.Text.Parsing.RuleParser
7322 {
7323 public SByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7324 {
7325 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7326 SetValueTypeName(ToUtf32("ConstantValue*"));
7327 }
7328 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7329 {
7330 parsingData->PushContext(Id(), new Context());
7331 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7332 UniquePtr<Object> context_value = stack.Pop();
7333 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7334 }
7335 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7336 {
7337 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7338 if (matched)
7339 {
7340 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7341 }
7342 parsingData->PopContext(Id());
7343 }
7344 public override void Link()
7345 {
7346 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7347 a0ActionParser->SetAction(A0Action);
7348 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7349 typeNonterminalParser->SetPre(Pretype);
7350 typeNonterminalParser->SetPost(Posttype);
7351 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7352 valNonterminalParser->SetPost(Postval);
7353 }
7354 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7355 {
7356 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7357 context->value = context->context->MakeSByteValue(cast<SByteType*>(context->fromtype), context->fromval);
7358 }
7359 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7360 {
7361 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7362 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7363 }
7364 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7365 {
7366 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7367 if (matched)
7368 {
7369 UniquePtr<Object> fromtype_value = stack.Pop();
7370 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7371 }
7372 }
7373 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7374 {
7375 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7376 if (matched)
7377 {
7378 UniquePtr<Object> fromval_value = stack.Pop();
7379 context->fromval = *cast<ValueObject<sbyte>*>(fromval_value.Get());
7380 }
7381 }
7382 public class Context : System.Text.Parsing.Context
7383 {
7384 public Context() : context(), value(), fromtype(), fromval()
7385 {
7386 }
7387 public cmsx.intermediate.Context* context;
7388 public ConstantValue* value;
7389 public Type* fromtype;
7390 public sbyte fromval;
7391 }
7392 }
7393
7394 public class SByteValueRule : System.Text.Parsing.RuleParser
7395 {
7396 public SByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7397 {
7398 SetValueTypeName(ToUtf32("sbyte"));
7399 }
7400 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7401 {
7402 parsingData->PushContext(Id(), new Context());
7403 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7404 }
7405 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7406 {
7407 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7408 if (matched)
7409 {
7410 stack.Push(UniquePtr<Object>(new ValueObject<sbyte>(context->value)));
7411 }
7412 parsingData->PopContext(Id());
7413 }
7414 public override void Link()
7415 {
7416 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7417 a0ActionParser->SetAction(A0Action);
7418 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7419 xNonterminalParser->SetPost(Postx);
7420 }
7421 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7422 {
7423 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7424 context->value = context->fromx;
7425 }
7426 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7427 {
7428 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7429 if (matched)
7430 {
7431 UniquePtr<Object> fromx_value = stack.Pop();
7432 context->fromx = *cast<ValueObject<sbyte>*>(fromx_value.Get());
7433 }
7434 }
7435 public class Context : System.Text.Parsing.Context
7436 {
7437 public Context() : value(), fromx()
7438 {
7439 }
7440 public sbyte value;
7441 public sbyte fromx;
7442 }
7443 }
7444
7445 public class ByteConstantRule : System.Text.Parsing.RuleParser
7446 {
7447 public ByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7448 {
7449 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7450 SetValueTypeName(ToUtf32("ConstantValue*"));
7451 }
7452 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7453 {
7454 parsingData->PushContext(Id(), new Context());
7455 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7456 UniquePtr<Object> context_value = stack.Pop();
7457 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7458 }
7459 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7460 {
7461 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7462 if (matched)
7463 {
7464 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7465 }
7466 parsingData->PopContext(Id());
7467 }
7468 public override void Link()
7469 {
7470 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7471 a0ActionParser->SetAction(A0Action);
7472 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7473 typeNonterminalParser->SetPre(Pretype);
7474 typeNonterminalParser->SetPost(Posttype);
7475 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7476 valNonterminalParser->SetPost(Postval);
7477 }
7478 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7479 {
7480 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7481 context->value = context->context->MakeByteValue(cast<ByteType*>(context->fromtype), context->fromval);
7482 }
7483 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7484 {
7485 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7486 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7487 }
7488 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7489 {
7490 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7491 if (matched)
7492 {
7493 UniquePtr<Object> fromtype_value = stack.Pop();
7494 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7495 }
7496 }
7497 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7498 {
7499 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7500 if (matched)
7501 {
7502 UniquePtr<Object> fromval_value = stack.Pop();
7503 context->fromval = *cast<ValueObject<byte>*>(fromval_value.Get());
7504 }
7505 }
7506 public class Context : System.Text.Parsing.Context
7507 {
7508 public Context() : context(), value(), fromtype(), fromval()
7509 {
7510 }
7511 public cmsx.intermediate.Context* context;
7512 public ConstantValue* value;
7513 public Type* fromtype;
7514 public byte fromval;
7515 }
7516 }
7517
7518 public class ByteValueRule : System.Text.Parsing.RuleParser
7519 {
7520 public ByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7521 {
7522 SetValueTypeName(ToUtf32("byte"));
7523 }
7524 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7525 {
7526 parsingData->PushContext(Id(), new Context());
7527 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7528 }
7529 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7530 {
7531 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7532 if (matched)
7533 {
7534 stack.Push(UniquePtr<Object>(new ValueObject<byte>(context->value)));
7535 }
7536 parsingData->PopContext(Id());
7537 }
7538 public override void Link()
7539 {
7540 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7541 a0ActionParser->SetAction(A0Action);
7542 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7543 xNonterminalParser->SetPost(Postx);
7544 }
7545 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7546 {
7547 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7548 context->value = context->fromx;
7549 }
7550 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7551 {
7552 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7553 if (matched)
7554 {
7555 UniquePtr<Object> fromx_value = stack.Pop();
7556 context->fromx = *cast<ValueObject<byte>*>(fromx_value.Get());
7557 }
7558 }
7559 public class Context : System.Text.Parsing.Context
7560 {
7561 public Context() : value(), fromx()
7562 {
7563 }
7564 public byte value;
7565 public byte fromx;
7566 }
7567 }
7568
7569 public class ShortConstantRule : System.Text.Parsing.RuleParser
7570 {
7571 public ShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7572 {
7573 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7574 SetValueTypeName(ToUtf32("ConstantValue*"));
7575 }
7576 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7577 {
7578 parsingData->PushContext(Id(), new Context());
7579 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7580 UniquePtr<Object> context_value = stack.Pop();
7581 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7582 }
7583 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7584 {
7585 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7586 if (matched)
7587 {
7588 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7589 }
7590 parsingData->PopContext(Id());
7591 }
7592 public override void Link()
7593 {
7594 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7595 a0ActionParser->SetAction(A0Action);
7596 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7597 typeNonterminalParser->SetPre(Pretype);
7598 typeNonterminalParser->SetPost(Posttype);
7599 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7600 valNonterminalParser->SetPost(Postval);
7601 }
7602 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7603 {
7604 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7605 context->value = context->context->MakeShortValue(cast<ShortType*>(context->fromtype), context->fromval);
7606 }
7607 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7608 {
7609 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7610 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7611 }
7612 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7613 {
7614 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7615 if (matched)
7616 {
7617 UniquePtr<Object> fromtype_value = stack.Pop();
7618 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7619 }
7620 }
7621 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7622 {
7623 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7624 if (matched)
7625 {
7626 UniquePtr<Object> fromval_value = stack.Pop();
7627 context->fromval = *cast<ValueObject<short>*>(fromval_value.Get());
7628 }
7629 }
7630 public class Context : System.Text.Parsing.Context
7631 {
7632 public Context() : context(), value(), fromtype(), fromval()
7633 {
7634 }
7635 public cmsx.intermediate.Context* context;
7636 public ConstantValue* value;
7637 public Type* fromtype;
7638 public short fromval;
7639 }
7640 }
7641
7642 public class ShortValueRule : System.Text.Parsing.RuleParser
7643 {
7644 public ShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7645 {
7646 SetValueTypeName(ToUtf32("short"));
7647 }
7648 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7649 {
7650 parsingData->PushContext(Id(), new Context());
7651 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7652 }
7653 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7654 {
7655 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7656 if (matched)
7657 {
7658 stack.Push(UniquePtr<Object>(new ValueObject<short>(context->value)));
7659 }
7660 parsingData->PopContext(Id());
7661 }
7662 public override void Link()
7663 {
7664 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7665 a0ActionParser->SetAction(A0Action);
7666 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7667 xNonterminalParser->SetPost(Postx);
7668 }
7669 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7670 {
7671 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7672 context->value = context->fromx;
7673 }
7674 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7675 {
7676 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7677 if (matched)
7678 {
7679 UniquePtr<Object> fromx_value = stack.Pop();
7680 context->fromx = *cast<ValueObject<short>*>(fromx_value.Get());
7681 }
7682 }
7683 public class Context : System.Text.Parsing.Context
7684 {
7685 public Context() : value(), fromx()
7686 {
7687 }
7688 public short value;
7689 public short fromx;
7690 }
7691 }
7692
7693 public class UShortConstantRule : System.Text.Parsing.RuleParser
7694 {
7695 public UShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7696 {
7697 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7698 SetValueTypeName(ToUtf32("ConstantValue*"));
7699 }
7700 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7701 {
7702 parsingData->PushContext(Id(), new Context());
7703 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7704 UniquePtr<Object> context_value = stack.Pop();
7705 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7706 }
7707 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7708 {
7709 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7710 if (matched)
7711 {
7712 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7713 }
7714 parsingData->PopContext(Id());
7715 }
7716 public override void Link()
7717 {
7718 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7719 a0ActionParser->SetAction(A0Action);
7720 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7721 typeNonterminalParser->SetPre(Pretype);
7722 typeNonterminalParser->SetPost(Posttype);
7723 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7724 valNonterminalParser->SetPost(Postval);
7725 }
7726 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7727 {
7728 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7729 context->value = context->context->MakeUShortValue(cast<UShortType*>(context->fromtype), context->fromval);
7730 }
7731 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7732 {
7733 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7734 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7735 }
7736 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7737 {
7738 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7739 if (matched)
7740 {
7741 UniquePtr<Object> fromtype_value = stack.Pop();
7742 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7743 }
7744 }
7745 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7746 {
7747 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7748 if (matched)
7749 {
7750 UniquePtr<Object> fromval_value = stack.Pop();
7751 context->fromval = *cast<ValueObject<ushort>*>(fromval_value.Get());
7752 }
7753 }
7754 public class Context : System.Text.Parsing.Context
7755 {
7756 public Context() : context(), value(), fromtype(), fromval()
7757 {
7758 }
7759 public cmsx.intermediate.Context* context;
7760 public ConstantValue* value;
7761 public Type* fromtype;
7762 public ushort fromval;
7763 }
7764 }
7765
7766 public class UShortValueRule : System.Text.Parsing.RuleParser
7767 {
7768 public UShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7769 {
7770 SetValueTypeName(ToUtf32("ushort"));
7771 }
7772 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7773 {
7774 parsingData->PushContext(Id(), new Context());
7775 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7776 }
7777 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7778 {
7779 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7780 if (matched)
7781 {
7782 stack.Push(UniquePtr<Object>(new ValueObject<ushort>(context->value)));
7783 }
7784 parsingData->PopContext(Id());
7785 }
7786 public override void Link()
7787 {
7788 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7789 a0ActionParser->SetAction(A0Action);
7790 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7791 xNonterminalParser->SetPost(Postx);
7792 }
7793 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7794 {
7795 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7796 context->value = context->fromx;
7797 }
7798 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7799 {
7800 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7801 if (matched)
7802 {
7803 UniquePtr<Object> fromx_value = stack.Pop();
7804 context->fromx = *cast<ValueObject<ushort>*>(fromx_value.Get());
7805 }
7806 }
7807 public class Context : System.Text.Parsing.Context
7808 {
7809 public Context() : value(), fromx()
7810 {
7811 }
7812 public ushort value;
7813 public ushort fromx;
7814 }
7815 }
7816
7817 public class IntConstantRule : System.Text.Parsing.RuleParser
7818 {
7819 public IntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7820 {
7821 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7822 SetValueTypeName(ToUtf32("ConstantValue*"));
7823 }
7824 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7825 {
7826 parsingData->PushContext(Id(), new Context());
7827 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7828 UniquePtr<Object> context_value = stack.Pop();
7829 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7830 }
7831 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7832 {
7833 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7834 if (matched)
7835 {
7836 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7837 }
7838 parsingData->PopContext(Id());
7839 }
7840 public override void Link()
7841 {
7842 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7843 a0ActionParser->SetAction(A0Action);
7844 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7845 typeNonterminalParser->SetPre(Pretype);
7846 typeNonterminalParser->SetPost(Posttype);
7847 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7848 valNonterminalParser->SetPost(Postval);
7849 }
7850 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7851 {
7852 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7853 context->value = context->context->MakeIntValue(cast<IntType*>(context->fromtype), context->fromval);
7854 }
7855 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7856 {
7857 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7858 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7859 }
7860 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7861 {
7862 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7863 if (matched)
7864 {
7865 UniquePtr<Object> fromtype_value = stack.Pop();
7866 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7867 }
7868 }
7869 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7870 {
7871 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7872 if (matched)
7873 {
7874 UniquePtr<Object> fromval_value = stack.Pop();
7875 context->fromval = *cast<ValueObject<int>*>(fromval_value.Get());
7876 }
7877 }
7878 public class Context : System.Text.Parsing.Context
7879 {
7880 public Context() : context(), value(), fromtype(), fromval()
7881 {
7882 }
7883 public cmsx.intermediate.Context* context;
7884 public ConstantValue* value;
7885 public Type* fromtype;
7886 public int fromval;
7887 }
7888 }
7889
7890 public class IntValueRule : System.Text.Parsing.RuleParser
7891 {
7892 public IntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7893 {
7894 SetValueTypeName(ToUtf32("int"));
7895 }
7896 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7897 {
7898 parsingData->PushContext(Id(), new Context());
7899 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7900 }
7901 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7902 {
7903 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7904 if (matched)
7905 {
7906 stack.Push(UniquePtr<Object>(new ValueObject<int>(context->value)));
7907 }
7908 parsingData->PopContext(Id());
7909 }
7910 public override void Link()
7911 {
7912 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7913 a0ActionParser->SetAction(A0Action);
7914 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
7915 xNonterminalParser->SetPost(Postx);
7916 }
7917 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7918 {
7919 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7920 context->value = context->fromx;
7921 }
7922 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7923 {
7924 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7925 if (matched)
7926 {
7927 UniquePtr<Object> fromx_value = stack.Pop();
7928 context->fromx = *cast<ValueObject<int>*>(fromx_value.Get());
7929 }
7930 }
7931 public class Context : System.Text.Parsing.Context
7932 {
7933 public Context() : value(), fromx()
7934 {
7935 }
7936 public int value;
7937 public int fromx;
7938 }
7939 }
7940
7941 public class UIntConstantRule : System.Text.Parsing.RuleParser
7942 {
7943 public UIntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
7944 {
7945 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
7946 SetValueTypeName(ToUtf32("ConstantValue*"));
7947 }
7948 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7949 {
7950 parsingData->PushContext(Id(), new Context());
7951 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7952 UniquePtr<Object> context_value = stack.Pop();
7953 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
7954 }
7955 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7956 {
7957 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7958 if (matched)
7959 {
7960 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
7961 }
7962 parsingData->PopContext(Id());
7963 }
7964 public override void Link()
7965 {
7966 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
7967 a0ActionParser->SetAction(A0Action);
7968 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
7969 typeNonterminalParser->SetPre(Pretype);
7970 typeNonterminalParser->SetPost(Posttype);
7971 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
7972 valNonterminalParser->SetPost(Postval);
7973 }
7974 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
7975 {
7976 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7977 context->value = context->context->MakeUIntValue(cast<UIntType*>(context->fromtype), context->fromval);
7978 }
7979 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
7980 {
7981 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7982 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
7983 }
7984 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7985 {
7986 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7987 if (matched)
7988 {
7989 UniquePtr<Object> fromtype_value = stack.Pop();
7990 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
7991 }
7992 }
7993 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
7994 {
7995 Context* context = cast<Context*>(parsingData->GetContext(Id()));
7996 if (matched)
7997 {
7998 UniquePtr<Object> fromval_value = stack.Pop();
7999 context->fromval = *cast<ValueObject<uint>*>(fromval_value.Get());
8000 }
8001 }
8002 public class Context : System.Text.Parsing.Context
8003 {
8004 public Context() : context(), value(), fromtype(), fromval()
8005 {
8006 }
8007 public cmsx.intermediate.Context* context;
8008 public ConstantValue* value;
8009 public Type* fromtype;
8010 public uint fromval;
8011 }
8012 }
8013
8014 public class UIntValueRule : System.Text.Parsing.RuleParser
8015 {
8016 public UIntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8017 {
8018 SetValueTypeName(ToUtf32("uint"));
8019 }
8020 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8021 {
8022 parsingData->PushContext(Id(), new Context());
8023 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8024 }
8025 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8026 {
8027 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8028 if (matched)
8029 {
8030 stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
8031 }
8032 parsingData->PopContext(Id());
8033 }
8034 public override void Link()
8035 {
8036 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8037 a0ActionParser->SetAction(A0Action);
8038 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8039 xNonterminalParser->SetPost(Postx);
8040 }
8041 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8042 {
8043 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8044 context->value = context->fromx;
8045 }
8046 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8047 {
8048 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8049 if (matched)
8050 {
8051 UniquePtr<Object> fromx_value = stack.Pop();
8052 context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
8053 }
8054 }
8055 public class Context : System.Text.Parsing.Context
8056 {
8057 public Context() : value(), fromx()
8058 {
8059 }
8060 public uint value;
8061 public uint fromx;
8062 }
8063 }
8064
8065 public class LongConstantRule : System.Text.Parsing.RuleParser
8066 {
8067 public LongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8068 {
8069 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8070 SetValueTypeName(ToUtf32("ConstantValue*"));
8071 }
8072 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8073 {
8074 parsingData->PushContext(Id(), new Context());
8075 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8076 UniquePtr<Object> context_value = stack.Pop();
8077 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8078 }
8079 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8080 {
8081 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8082 if (matched)
8083 {
8084 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8085 }
8086 parsingData->PopContext(Id());
8087 }
8088 public override void Link()
8089 {
8090 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8091 a0ActionParser->SetAction(A0Action);
8092 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8093 typeNonterminalParser->SetPre(Pretype);
8094 typeNonterminalParser->SetPost(Posttype);
8095 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8096 valNonterminalParser->SetPost(Postval);
8097 }
8098 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8099 {
8100 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8101 context->value = context->context->MakeLongValue(cast<LongType*>(context->fromtype), context->fromval);
8102 }
8103 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8104 {
8105 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8106 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8107 }
8108 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8109 {
8110 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8111 if (matched)
8112 {
8113 UniquePtr<Object> fromtype_value = stack.Pop();
8114 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8115 }
8116 }
8117 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8118 {
8119 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8120 if (matched)
8121 {
8122 UniquePtr<Object> fromval_value = stack.Pop();
8123 context->fromval = *cast<ValueObject<long>*>(fromval_value.Get());
8124 }
8125 }
8126 public class Context : System.Text.Parsing.Context
8127 {
8128 public Context() : context(), value(), fromtype(), fromval()
8129 {
8130 }
8131 public cmsx.intermediate.Context* context;
8132 public ConstantValue* value;
8133 public Type* fromtype;
8134 public long fromval;
8135 }
8136 }
8137
8138 public class LongValueRule : System.Text.Parsing.RuleParser
8139 {
8140 public LongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8141 {
8142 SetValueTypeName(ToUtf32("long"));
8143 }
8144 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8145 {
8146 parsingData->PushContext(Id(), new Context());
8147 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8148 }
8149 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8150 {
8151 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8152 if (matched)
8153 {
8154 stack.Push(UniquePtr<Object>(new ValueObject<long>(context->value)));
8155 }
8156 parsingData->PopContext(Id());
8157 }
8158 public override void Link()
8159 {
8160 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8161 a0ActionParser->SetAction(A0Action);
8162 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8163 xNonterminalParser->SetPost(Postx);
8164 }
8165 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8166 {
8167 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8168 context->value = context->fromx;
8169 }
8170 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8171 {
8172 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8173 if (matched)
8174 {
8175 UniquePtr<Object> fromx_value = stack.Pop();
8176 context->fromx = *cast<ValueObject<long>*>(fromx_value.Get());
8177 }
8178 }
8179 public class Context : System.Text.Parsing.Context
8180 {
8181 public Context() : value(), fromx()
8182 {
8183 }
8184 public long value;
8185 public long fromx;
8186 }
8187 }
8188
8189 public class ULongConstantRule : System.Text.Parsing.RuleParser
8190 {
8191 public ULongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8192 {
8193 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8194 SetValueTypeName(ToUtf32("ConstantValue*"));
8195 }
8196 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8197 {
8198 parsingData->PushContext(Id(), new Context());
8199 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8200 UniquePtr<Object> context_value = stack.Pop();
8201 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8202 }
8203 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8204 {
8205 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8206 if (matched)
8207 {
8208 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8209 }
8210 parsingData->PopContext(Id());
8211 }
8212 public override void Link()
8213 {
8214 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8215 a0ActionParser->SetAction(A0Action);
8216 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8217 typeNonterminalParser->SetPre(Pretype);
8218 typeNonterminalParser->SetPost(Posttype);
8219 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8220 valNonterminalParser->SetPost(Postval);
8221 }
8222 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8223 {
8224 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8225 context->value = context->context->MakeULongValue(cast<ULongType*>(context->fromtype), context->fromval);
8226 }
8227 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8228 {
8229 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8230 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8231 }
8232 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8233 {
8234 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8235 if (matched)
8236 {
8237 UniquePtr<Object> fromtype_value = stack.Pop();
8238 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8239 }
8240 }
8241 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8242 {
8243 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8244 if (matched)
8245 {
8246 UniquePtr<Object> fromval_value = stack.Pop();
8247 context->fromval = *cast<ValueObject<ulong>*>(fromval_value.Get());
8248 }
8249 }
8250 public class Context : System.Text.Parsing.Context
8251 {
8252 public Context() : context(), value(), fromtype(), fromval()
8253 {
8254 }
8255 public cmsx.intermediate.Context* context;
8256 public ConstantValue* value;
8257 public Type* fromtype;
8258 public ulong fromval;
8259 }
8260 }
8261
8262 public class ULongValueRule : System.Text.Parsing.RuleParser
8263 {
8264 public ULongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8265 {
8266 SetValueTypeName(ToUtf32("ulong"));
8267 }
8268 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8269 {
8270 parsingData->PushContext(Id(), new Context());
8271 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8272 }
8273 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8274 {
8275 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8276 if (matched)
8277 {
8278 stack.Push(UniquePtr<Object>(new ValueObject<ulong>(context->value)));
8279 }
8280 parsingData->PopContext(Id());
8281 }
8282 public override void Link()
8283 {
8284 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8285 a0ActionParser->SetAction(A0Action);
8286 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8287 xNonterminalParser->SetPost(Postx);
8288 }
8289 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8290 {
8291 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8292 context->value = context->fromx;
8293 }
8294 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8295 {
8296 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8297 if (matched)
8298 {
8299 UniquePtr<Object> fromx_value = stack.Pop();
8300 context->fromx = *cast<ValueObject<ulong>*>(fromx_value.Get());
8301 }
8302 }
8303 public class Context : System.Text.Parsing.Context
8304 {
8305 public Context() : value(), fromx()
8306 {
8307 }
8308 public ulong value;
8309 public ulong fromx;
8310 }
8311 }
8312
8313 public class FloatConstantRule : System.Text.Parsing.RuleParser
8314 {
8315 public FloatConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8316 {
8317 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8318 SetValueTypeName(ToUtf32("ConstantValue*"));
8319 }
8320 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8321 {
8322 parsingData->PushContext(Id(), new Context());
8323 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8324 UniquePtr<Object> context_value = stack.Pop();
8325 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8326 }
8327 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8328 {
8329 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8330 if (matched)
8331 {
8332 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8333 }
8334 parsingData->PopContext(Id());
8335 }
8336 public override void Link()
8337 {
8338 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8339 a0ActionParser->SetAction(A0Action);
8340 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8341 typeNonterminalParser->SetPre(Pretype);
8342 typeNonterminalParser->SetPost(Posttype);
8343 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8344 valNonterminalParser->SetPost(Postval);
8345 }
8346 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8347 {
8348 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8349 context->value = context->context->MakeFloatValue(cast<FloatType*>(context->fromtype), context->fromval);
8350 }
8351 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8352 {
8353 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8354 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8355 }
8356 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8357 {
8358 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8359 if (matched)
8360 {
8361 UniquePtr<Object> fromtype_value = stack.Pop();
8362 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8363 }
8364 }
8365 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8366 {
8367 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8368 if (matched)
8369 {
8370 UniquePtr<Object> fromval_value = stack.Pop();
8371 context->fromval = *cast<ValueObject<float>*>(fromval_value.Get());
8372 }
8373 }
8374 public class Context : System.Text.Parsing.Context
8375 {
8376 public Context() : context(), value(), fromtype(), fromval()
8377 {
8378 }
8379 public cmsx.intermediate.Context* context;
8380 public ConstantValue* value;
8381 public Type* fromtype;
8382 public float fromval;
8383 }
8384 }
8385
8386 public class FloatValueRule : System.Text.Parsing.RuleParser
8387 {
8388 public FloatValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8389 {
8390 SetValueTypeName(ToUtf32("float"));
8391 }
8392 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8393 {
8394 parsingData->PushContext(Id(), new Context());
8395 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8396 }
8397 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8398 {
8399 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8400 if (matched)
8401 {
8402 stack.Push(UniquePtr<Object>(new ValueObject<float>(context->value)));
8403 }
8404 parsingData->PopContext(Id());
8405 }
8406 public override void Link()
8407 {
8408 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8409 a0ActionParser->SetAction(A0Action);
8410 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8411 xNonterminalParser->SetPost(Postx);
8412 }
8413 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8414 {
8415 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8416 context->value = context->fromx;
8417 }
8418 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8419 {
8420 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8421 if (matched)
8422 {
8423 UniquePtr<Object> fromx_value = stack.Pop();
8424 context->fromx = *cast<ValueObject<float>*>(fromx_value.Get());
8425 }
8426 }
8427 public class Context : System.Text.Parsing.Context
8428 {
8429 public Context() : value(), fromx()
8430 {
8431 }
8432 public float value;
8433 public float fromx;
8434 }
8435 }
8436
8437 public class DoubleConstantRule : System.Text.Parsing.RuleParser
8438 {
8439 public DoubleConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8440 {
8441 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8442 SetValueTypeName(ToUtf32("ConstantValue*"));
8443 }
8444 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8445 {
8446 parsingData->PushContext(Id(), new Context());
8447 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8448 UniquePtr<Object> context_value = stack.Pop();
8449 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8450 }
8451 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8452 {
8453 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8454 if (matched)
8455 {
8456 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8457 }
8458 parsingData->PopContext(Id());
8459 }
8460 public override void Link()
8461 {
8462 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8463 a0ActionParser->SetAction(A0Action);
8464 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8465 typeNonterminalParser->SetPre(Pretype);
8466 typeNonterminalParser->SetPost(Posttype);
8467 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
8468 valNonterminalParser->SetPost(Postval);
8469 }
8470 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8471 {
8472 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8473 context->value = context->context->MakeDoubleValue(cast<DoubleType*>(context->fromtype), context->fromval);
8474 }
8475 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8476 {
8477 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8478 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8479 }
8480 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8481 {
8482 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8483 if (matched)
8484 {
8485 UniquePtr<Object> fromtype_value = stack.Pop();
8486 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8487 }
8488 }
8489 public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8490 {
8491 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8492 if (matched)
8493 {
8494 UniquePtr<Object> fromval_value = stack.Pop();
8495 context->fromval = *cast<ValueObject<double>*>(fromval_value.Get());
8496 }
8497 }
8498 public class Context : System.Text.Parsing.Context
8499 {
8500 public Context() : context(), value(), fromtype(), fromval()
8501 {
8502 }
8503 public cmsx.intermediate.Context* context;
8504 public ConstantValue* value;
8505 public Type* fromtype;
8506 public double fromval;
8507 }
8508 }
8509
8510 public class DoubleValueRule : System.Text.Parsing.RuleParser
8511 {
8512 public DoubleValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8513 {
8514 SetValueTypeName(ToUtf32("double"));
8515 }
8516 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8517 {
8518 parsingData->PushContext(Id(), new Context());
8519 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8520 }
8521 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8522 {
8523 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8524 if (matched)
8525 {
8526 stack.Push(UniquePtr<Object>(new ValueObject<double>(context->value)));
8527 }
8528 parsingData->PopContext(Id());
8529 }
8530 public override void Link()
8531 {
8532 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8533 a0ActionParser->SetAction(A0Action);
8534 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
8535 xNonterminalParser->SetPost(Postx);
8536 }
8537 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8538 {
8539 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8540 context->value = context->fromx;
8541 }
8542 public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8543 {
8544 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8545 if (matched)
8546 {
8547 UniquePtr<Object> fromx_value = stack.Pop();
8548 context->fromx = *cast<ValueObject<double>*>(fromx_value.Get());
8549 }
8550 }
8551 public class Context : System.Text.Parsing.Context
8552 {
8553 public Context() : value(), fromx()
8554 {
8555 }
8556 public double value;
8557 public double fromx;
8558 }
8559 }
8560
8561 public class PtrConstantRule : System.Text.Parsing.RuleParser
8562 {
8563 public PtrConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8564 {
8565 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8566 SetValueTypeName(ToUtf32("ConstantValue*"));
8567 }
8568 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8569 {
8570 parsingData->PushContext(Id(), new Context());
8571 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8572 UniquePtr<Object> context_value = stack.Pop();
8573 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8574 }
8575 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8576 {
8577 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8578 if (matched)
8579 {
8580 stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
8581 }
8582 parsingData->PopContext(Id());
8583 }
8584 public override void Link()
8585 {
8586 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8587 a0ActionParser->SetAction(A0Action);
8588 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
8589 a1ActionParser->SetAction(A1Action);
8590 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
8591 typeNonterminalParser->SetPre(Pretype);
8592 typeNonterminalParser->SetPost(Posttype);
8593 }
8594 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8595 {
8596 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8597 context->value = cast<PtrType*>(context->fromtype)->DefaultValue();
8598 }
8599 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8600 {
8601 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8602 pass = IsPtrType(context->fromtype);
8603 }
8604 public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8605 {
8606 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8607 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8608 }
8609 public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8610 {
8611 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8612 if (matched)
8613 {
8614 UniquePtr<Object> fromtype_value = stack.Pop();
8615 context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
8616 }
8617 }
8618 public class Context : System.Text.Parsing.Context
8619 {
8620 public Context() : context(), value(), fromtype()
8621 {
8622 }
8623 public cmsx.intermediate.Context* context;
8624 public ConstantValue* value;
8625 public Type* fromtype;
8626 }
8627 }
8628
8629 public class ArrayConstantRule : System.Text.Parsing.RuleParser
8630 {
8631 public ArrayConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8632 {
8633 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8634 SetValueTypeName(ToUtf32("ArrayValue*"));
8635 }
8636 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8637 {
8638 parsingData->PushContext(Id(), new Context());
8639 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8640 UniquePtr<Object> context_value = stack.Pop();
8641 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8642 }
8643 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8644 {
8645 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8646 if (matched)
8647 {
8648 stack.Push(UniquePtr<Object>(new ValueObject<ArrayValue*>(context->value)));
8649 }
8650 parsingData->PopContext(Id());
8651 }
8652 public override void Link()
8653 {
8654 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8655 a0ActionParser->SetAction(A0Action);
8656 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
8657 a1ActionParser->SetAction(A1Action);
8658 NonterminalParser* elementNonterminalParser = GetNonterminal(ToUtf32("element"));
8659 elementNonterminalParser->SetPre(Preelement);
8660 elementNonterminalParser->SetPost(Postelement);
8661 }
8662 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8663 {
8664 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8665 context->value = context->context->MakeArrayValue();
8666 }
8667 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8668 {
8669 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8670 context->value->AddElement(context->fromelement);
8671 }
8672 public void Preelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8673 {
8674 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8675 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8676 }
8677 public void Postelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8678 {
8679 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8680 if (matched)
8681 {
8682 UniquePtr<Object> fromelement_value = stack.Pop();
8683 context->fromelement = *cast<ValueObject<ConstantValue*>*>(fromelement_value.Get());
8684 }
8685 }
8686 public class Context : System.Text.Parsing.Context
8687 {
8688 public Context() : context(), value(), fromelement()
8689 {
8690 }
8691 public cmsx.intermediate.Context* context;
8692 public ArrayValue* value;
8693 public ConstantValue* fromelement;
8694 }
8695 }
8696
8697 public class StructureConstantRule : System.Text.Parsing.RuleParser
8698 {
8699 public StructureConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
8700 {
8701 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
8702 SetValueTypeName(ToUtf32("StructureValue*"));
8703 }
8704 public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8705 {
8706 parsingData->PushContext(Id(), new Context());
8707 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8708 UniquePtr<Object> context_value = stack.Pop();
8709 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
8710 }
8711 public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8712 {
8713 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8714 if (matched)
8715 {
8716 stack.Push(UniquePtr<Object>(new ValueObject<StructureValue*>(context->value)));
8717 }
8718 parsingData->PopContext(Id());
8719 }
8720 public override void Link()
8721 {
8722 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
8723 a0ActionParser->SetAction(A0Action);
8724 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
8725 a1ActionParser->SetAction(A1Action);
8726 NonterminalParser* memberNonterminalParser = GetNonterminal(ToUtf32("member"));
8727 memberNonterminalParser->SetPre(Premember);
8728 memberNonterminalParser->SetPost(Postmember);
8729 }
8730 public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8731 {
8732 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8733 context->value = context->context->MakeStructureValue();
8734 }
8735 public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
8736 {
8737 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8738 context->value->AddMember(context->frommember);
8739 }
8740 public void Premember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
8741 {
8742 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8743 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
8744 }
8745 public void Postmember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
8746 {
8747 Context* context = cast<Context*>(parsingData->GetContext(Id()));
8748 if (matched)
8749 {
8750 UniquePtr<Object> frommember_value = stack.Pop();
8751 context->frommember = *cast<ValueObject<ConstantValue*>*>(frommember_value.Get());
8752 }
8753 }
8754 public class Context : System.Text.Parsing.Context
8755 {
8756 public Context() : context(), value(), frommember()
8757 {
8758 }
8759 public cmsx.intermediate.Context* context;
8760 public StructureValue* value;
8761 public ConstantValue* frommember;
8762 }
8763 }
8764
8765 public override void GetReferencedGrammars()
8766 {
8767 ParsingDomain* pd = Domain();
8768 Grammar* grammar0 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
8769 if (grammar0 == null)
8770 {
8771 grammar0 = new System.Text.Parsing.stdlib(pd);
8772 }
8773 AddGrammarReference(grammar0);
8774 }
8775 public override void CreateRules()
8776 {
8777 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("identifier"), this, ToUtf32("System.Text.Parsing.stdlib.identifier")));
8778 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("newline"), this, ToUtf32("System.Text.Parsing.stdlib.newline")));
8779 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("bool"), this, ToUtf32("System.Text.Parsing.stdlib.bool")));
8780 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("sbyte"), this, ToUtf32("System.Text.Parsing.stdlib.sbyte")));
8781 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("byte"), this, ToUtf32("System.Text.Parsing.stdlib.byte")));
8782 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("short"), this, ToUtf32("System.Text.Parsing.stdlib.short")));
8783 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ushort"), this, ToUtf32("System.Text.Parsing.stdlib.ushort")));
8784 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("int"), this, ToUtf32("System.Text.Parsing.stdlib.int")));
8785 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("uint"), this, ToUtf32("System.Text.Parsing.stdlib.uint")));
8786 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("long"), this, ToUtf32("System.Text.Parsing.stdlib.long")));
8787 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ulong"), this, ToUtf32("System.Text.Parsing.stdlib.ulong")));
8788 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("float"), this, ToUtf32("System.Text.Parsing.stdlib.float")));
8789 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("double"), this, ToUtf32("System.Text.Parsing.stdlib.double")));
8790 AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("spaces"), this, ToUtf32("System.Text.Parsing.stdlib.spaces")));
8791 AddRule(new IntermediateCodeFileRule(ToUtf32("IntermediateCodeFile"), GetScope(), Domain()->GetNextRuleId(),
8792 new System.Text.Parsing.SequenceParser(
8793 new System.Text.Parsing.SequenceParser(
8794 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8795 new System.Text.Parsing.EmptyParser()),
8796 new System.Text.Parsing.OptionalParser(
8797 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclarations"), ToUtf32("TypeDeclarations"), 1))),
8798 new System.Text.Parsing.OptionalParser(
8799 new System.Text.Parsing.NonterminalParser(ToUtf32("Functions"), ToUtf32("Functions"), 1)))));
8800 AddRule(new TypeDeclarationsRule(ToUtf32("TypeDeclarations"), GetScope(), Domain()->GetNextRuleId(),
8801 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8802 new System.Text.Parsing.GroupingParser(
8803 new System.Text.Parsing.SequenceParser(
8804 new System.Text.Parsing.SequenceParser(
8805 new System.Text.Parsing.SequenceParser(
8806 new System.Text.Parsing.KeywordParser(ToUtf32("types")),
8807 new System.Text.Parsing.ExpectationParser(
8808 new System.Text.Parsing.CharParser('{'))),
8809 new System.Text.Parsing.KleeneStarParser(
8810 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclaration"), ToUtf32("TypeDeclaration"), 1))),
8811 new System.Text.Parsing.ExpectationParser(
8812 new System.Text.Parsing.CharParser('}')))))));
8813 AddRule(new DataDefinitionsRule(ToUtf32("DataDefinitions"), GetScope(), Domain()->GetNextRuleId(),
8814 new System.Text.Parsing.SequenceParser(
8815 new System.Text.Parsing.SequenceParser(
8816 new System.Text.Parsing.SequenceParser(
8817 new System.Text.Parsing.KeywordParser(ToUtf32("data")),
8818 new System.Text.Parsing.ExpectationParser(
8819 new System.Text.Parsing.CharParser('{'))),
8820 new System.Text.Parsing.KleeneStarParser(
8821 new System.Text.Parsing.NonterminalParser(ToUtf32("DataDefinition"), ToUtf32("DataDefinition"), 1))),
8822 new System.Text.Parsing.ExpectationParser(
8823 new System.Text.Parsing.CharParser('}')))));
8824 AddRule(new FunctionsRule(ToUtf32("Functions"), GetScope(), Domain()->GetNextRuleId(),
8825 new System.Text.Parsing.KleeneStarParser(
8826 new System.Text.Parsing.NonterminalParser(ToUtf32("Function"), ToUtf32("Function"), 1))));
8827 AddRule(new FunctionRule(ToUtf32("Function"), GetScope(), Domain()->GetNextRuleId(),
8828 new System.Text.Parsing.SequenceParser(
8829 new System.Text.Parsing.SequenceParser(
8830 new System.Text.Parsing.SequenceParser(
8831 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8832 new System.Text.Parsing.NonterminalParser(ToUtf32("function"), ToUtf32("FunctionHeader"), 1)),
8833 new System.Text.Parsing.ExpectationParser(
8834 new System.Text.Parsing.CharParser('{'))),
8835 new System.Text.Parsing.KleeneStarParser(
8836 new System.Text.Parsing.NonterminalParser(ToUtf32("BasicBlock"), ToUtf32("BasicBlock"), 2))),
8837 new System.Text.Parsing.ExpectationParser(
8838 new System.Text.Parsing.CharParser('}')))));
8839 AddRule(new FunctionHeaderRule(ToUtf32("FunctionHeader"), GetScope(), Domain()->GetNextRuleId(),
8840 new System.Text.Parsing.SequenceParser(
8841 new System.Text.Parsing.SequenceParser(
8842 new System.Text.Parsing.KeywordParser(ToUtf32("function")),
8843 new System.Text.Parsing.ExpectationParser(
8844 new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))),
8845 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8846 new System.Text.Parsing.ExpectationParser(
8847 new System.Text.Parsing.NonterminalParser(ToUtf32("functionId"), ToUtf32("identifier"), 0))))));
8848 AddRule(new BasicBlockRule(ToUtf32("BasicBlock"), GetScope(), Domain()->GetNextRuleId(),
8849 new System.Text.Parsing.TokenParser(
8850 new System.Text.Parsing.SequenceParser(
8851 new System.Text.Parsing.SequenceParser(
8852 new System.Text.Parsing.SequenceParser(
8853 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8854 new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("Label"), 0)),
8855 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8856 new System.Text.Parsing.PositiveParser(
8857 new System.Text.Parsing.NonterminalParser(ToUtf32("InstructionLine"), ToUtf32("InstructionLine"), 2))),
8858 new System.Text.Parsing.OptionalParser(
8859 new System.Text.Parsing.NonterminalParser(ToUtf32("EmptyLine"), ToUtf32("EmptyLine"), 0))))));
8860 AddRule(new System.Text.Parsing.RuleParser(ToUtf32("EmptyLine"), GetScope(), Domain()->GetNextRuleId(),
8861 new System.Text.Parsing.TokenParser(
8862 new System.Text.Parsing.SequenceParser(
8863 new System.Text.Parsing.OptionalParser(
8864 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8865 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))));
8866 AddRule(new InstructionLineRule(ToUtf32("InstructionLine"), GetScope(), Domain()->GetNextRuleId(),
8867 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8868 new System.Text.Parsing.TokenParser(
8869 new System.Text.Parsing.SequenceParser(
8870 new System.Text.Parsing.SequenceParser(
8871 new System.Text.Parsing.SequenceParser(
8872 new System.Text.Parsing.OptionalParser(
8873 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8874 new System.Text.Parsing.NonterminalParser(ToUtf32("Instruction"), ToUtf32("Instruction"), 1)),
8875 new System.Text.Parsing.OptionalParser(
8876 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
8877 new System.Text.Parsing.ExpectationParser(
8878 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))))));
8879 AddRule(new InstructionRule(ToUtf32("Instruction"), GetScope(), Domain()->GetNextRuleId(),
8880 new System.Text.Parsing.AlternativeParser(
8881 new System.Text.Parsing.AlternativeParser(
8882 new System.Text.Parsing.AlternativeParser(
8883 new System.Text.Parsing.AlternativeParser(
8884 new System.Text.Parsing.AlternativeParser(
8885 new System.Text.Parsing.AlternativeParser(
8886 new System.Text.Parsing.AlternativeParser(
8887 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8888 new System.Text.Parsing.NonterminalParser(ToUtf32("StoreInstruction"), ToUtf32("StoreInstruction"), 1)),
8889 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
8890 new System.Text.Parsing.NonterminalParser(ToUtf32("ArgInstruction"), ToUtf32("ArgInstruction"), 1))),
8891 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
8892 new System.Text.Parsing.NonterminalParser(ToUtf32("JumpInstruction"), ToUtf32("JumpInstruction"), 1))),
8893 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
8894 new System.Text.Parsing.NonterminalParser(ToUtf32("BranchInstruction"), ToUtf32("BranchInstruction"), 1))),
8895 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
8896 new System.Text.Parsing.NonterminalParser(ToUtf32("ProcedureCallInstruction"), ToUtf32("ProcedureCallInstruction"), 1))),
8897 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
8898 new System.Text.Parsing.NonterminalParser(ToUtf32("RetInstruction"), ToUtf32("RetInstruction"), 1))),
8899 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
8900 new System.Text.Parsing.NonterminalParser(ToUtf32("SwitchInstruction"), ToUtf32("SwitchInstruction"), 1))),
8901 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
8902 new System.Text.Parsing.NonterminalParser(ToUtf32("ValueInstruction"), ToUtf32("ValueInstruction"), 1)))));
8903 AddRule(new StoreInstructionRule(ToUtf32("StoreInstruction"), GetScope(), Domain()->GetNextRuleId(),
8904 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8905 new System.Text.Parsing.GroupingParser(
8906 new System.Text.Parsing.SequenceParser(
8907 new System.Text.Parsing.SequenceParser(
8908 new System.Text.Parsing.SequenceParser(
8909 new System.Text.Parsing.SequenceParser(
8910 new System.Text.Parsing.SequenceParser(
8911 new System.Text.Parsing.SequenceParser(
8912 new System.Text.Parsing.SequenceParser(
8913 new System.Text.Parsing.SequenceParser(
8914 new System.Text.Parsing.KeywordParser(ToUtf32("store")),
8915 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8916 new System.Text.Parsing.ExpectationParser(
8917 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
8918 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8919 new System.Text.Parsing.ExpectationParser(
8920 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))),
8921 new System.Text.Parsing.ExpectationParser(
8922 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
8923 new System.Text.Parsing.ExpectationParser(
8924 new System.Text.Parsing.NonterminalParser(ToUtf32("ptrType"), ToUtf32("TypeExpr"), 1))),
8925 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8926 new System.Text.Parsing.ExpectationParser(
8927 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Value"), 2)))))));
8928 AddRule(new ArgInstructionRule(ToUtf32("ArgInstruction"), GetScope(), Domain()->GetNextRuleId(),
8929 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8930 new System.Text.Parsing.GroupingParser(
8931 new System.Text.Parsing.SequenceParser(
8932 new System.Text.Parsing.SequenceParser(
8933 new System.Text.Parsing.SequenceParser(
8934 new System.Text.Parsing.SequenceParser(
8935 new System.Text.Parsing.KeywordParser(ToUtf32("arg")),
8936 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8937 new System.Text.Parsing.ExpectationParser(
8938 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
8939 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8940 new System.Text.Parsing.ExpectationParser(
8941 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Value"), 2)))))));
8942 AddRule(new JumpInstructionRule(ToUtf32("JumpInstruction"), GetScope(), Domain()->GetNextRuleId(),
8943 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8944 new System.Text.Parsing.GroupingParser(
8945 new System.Text.Parsing.SequenceParser(
8946 new System.Text.Parsing.SequenceParser(
8947 new System.Text.Parsing.KeywordParser(ToUtf32("jmp")),
8948 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8949 new System.Text.Parsing.ExpectationParser(
8950 new System.Text.Parsing.NonterminalParser(ToUtf32("target"), ToUtf32("Label"), 0)))))));
8951 AddRule(new BranchInstructionRule(ToUtf32("BranchInstruction"), GetScope(), Domain()->GetNextRuleId(),
8952 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8953 new System.Text.Parsing.GroupingParser(
8954 new System.Text.Parsing.SequenceParser(
8955 new System.Text.Parsing.SequenceParser(
8956 new System.Text.Parsing.SequenceParser(
8957 new System.Text.Parsing.SequenceParser(
8958 new System.Text.Parsing.SequenceParser(
8959 new System.Text.Parsing.SequenceParser(
8960 new System.Text.Parsing.SequenceParser(
8961 new System.Text.Parsing.SequenceParser(
8962 new System.Text.Parsing.KeywordParser(ToUtf32("branch")),
8963 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8964 new System.Text.Parsing.ExpectationParser(
8965 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
8966 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8967 new System.Text.Parsing.ExpectationParser(
8968 new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))),
8969 new System.Text.Parsing.ExpectationParser(
8970 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
8971 new System.Text.Parsing.ExpectationParser(
8972 new System.Text.Parsing.NonterminalParser(ToUtf32("trueTarget"), ToUtf32("Label"), 0))),
8973 new System.Text.Parsing.ExpectationParser(
8974 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
8975 new System.Text.Parsing.ExpectationParser(
8976 new System.Text.Parsing.NonterminalParser(ToUtf32("falseTarget"), ToUtf32("Label"), 0)))))));
8977 AddRule(new ProcedureCallInstructionRule(ToUtf32("ProcedureCallInstruction"), GetScope(), Domain()->GetNextRuleId(),
8978 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8979 new System.Text.Parsing.GroupingParser(
8980 new System.Text.Parsing.SequenceParser(
8981 new System.Text.Parsing.SequenceParser(
8982 new System.Text.Parsing.SequenceParser(
8983 new System.Text.Parsing.SequenceParser(
8984 new System.Text.Parsing.KeywordParser(ToUtf32("call")),
8985 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8986 new System.Text.Parsing.ExpectationParser(
8987 new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))),
8988 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8989 new System.Text.Parsing.ExpectationParser(
8990 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
8991 AddRule(new RetInstructionRule(ToUtf32("RetInstruction"), GetScope(), Domain()->GetNextRuleId(),
8992 new System.Text.Parsing.SequenceParser(
8993 new System.Text.Parsing.SequenceParser(
8994 new System.Text.Parsing.KeywordParser(ToUtf32("ret")),
8995 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
8996 new System.Text.Parsing.GroupingParser(
8997 new System.Text.Parsing.AlternativeParser(
8998 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
8999 new System.Text.Parsing.GroupingParser(
9000 new System.Text.Parsing.DifferenceParser(
9001 new System.Text.Parsing.KeywordParser(ToUtf32("void")),
9002 new System.Text.Parsing.StringParser(ToUtf32("void*"))))),
9003 new System.Text.Parsing.SequenceParser(
9004 new System.Text.Parsing.SequenceParser(
9005 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
9006 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9007 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9008 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))))))));
9009 AddRule(new SwitchInstructionRule(ToUtf32("SwitchInstruction"), GetScope(), Domain()->GetNextRuleId(),
9010 new System.Text.Parsing.SequenceParser(
9011 new System.Text.Parsing.SequenceParser(
9012 new System.Text.Parsing.SequenceParser(
9013 new System.Text.Parsing.SequenceParser(
9014 new System.Text.Parsing.SequenceParser(
9015 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9016 new System.Text.Parsing.GroupingParser(
9017 new System.Text.Parsing.SequenceParser(
9018 new System.Text.Parsing.SequenceParser(
9019 new System.Text.Parsing.SequenceParser(
9020 new System.Text.Parsing.SequenceParser(
9021 new System.Text.Parsing.SequenceParser(
9022 new System.Text.Parsing.SequenceParser(
9023 new System.Text.Parsing.KeywordParser(ToUtf32("switch")),
9024 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9025 new System.Text.Parsing.ExpectationParser(
9026 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))),
9027 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9028 new System.Text.Parsing.ExpectationParser(
9029 new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))),
9030 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9031 new System.Text.Parsing.ExpectationParser(
9032 new System.Text.Parsing.NonterminalParser(ToUtf32("defaultTarget"), ToUtf32("Label"), 0))))),
9033 new System.Text.Parsing.ExpectationParser(
9034 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9035 new System.Text.Parsing.ExpectationParser(
9036 new System.Text.Parsing.CharParser('['))),
9037 new System.Text.Parsing.OptionalParser(
9038 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
9039 new System.Text.Parsing.ListParser(
9040 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9041 new System.Text.Parsing.GroupingParser(
9042 new System.Text.Parsing.SequenceParser(
9043 new System.Text.Parsing.SequenceParser(
9044 new System.Text.Parsing.SequenceParser(
9045 new System.Text.Parsing.SequenceParser(
9046 new System.Text.Parsing.NonterminalParser(ToUtf32("caseType"), ToUtf32("TypeExpr"), 1),
9047 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9048 new System.Text.Parsing.NonterminalParser(ToUtf32("caseValue"), ToUtf32("Value"), 2)),
9049 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0)),
9050 new System.Text.Parsing.NonterminalParser(ToUtf32("caseTarget"), ToUtf32("Label"), 0)))),
9051 new System.Text.Parsing.GroupingParser(
9052 new System.Text.Parsing.SequenceParser(
9053 new System.Text.Parsing.SequenceParser(
9054 new System.Text.Parsing.OptionalParser(
9055 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9056 new System.Text.Parsing.CharParser(':')),
9057 new System.Text.Parsing.OptionalParser(
9058 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))))),
9059 new System.Text.Parsing.ExpectationParser(
9060 new System.Text.Parsing.CharParser(']')))));
9061 AddRule(new ValueInstructionRule(ToUtf32("ValueInstruction"), GetScope(), Domain()->GetNextRuleId(),
9062 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9063 new System.Text.Parsing.GroupingParser(
9064 new System.Text.Parsing.SequenceParser(
9065 new System.Text.Parsing.SequenceParser(
9066 new System.Text.Parsing.SequenceParser(
9067 new System.Text.Parsing.SequenceParser(
9068 new System.Text.Parsing.SequenceParser(
9069 new System.Text.Parsing.SequenceParser(
9070 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
9071 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9072 new System.Text.Parsing.ExpectationParser(
9073 new System.Text.Parsing.NonterminalParser(ToUtf32("result"), ToUtf32("Value"), 2))),
9074 new System.Text.Parsing.OptionalParser(
9075 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
9076 new System.Text.Parsing.CharParser('=')),
9077 new System.Text.Parsing.OptionalParser(
9078 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))),
9079 new System.Text.Parsing.ExpectationParser(
9080 new System.Text.Parsing.NonterminalParser(ToUtf32("Operation"), ToUtf32("Operation"), 2)))))));
9081 AddRule(new OperationRule(ToUtf32("Operation"), GetScope(), Domain()->GetNextRuleId(),
9082 new System.Text.Parsing.AlternativeParser(
9083 new System.Text.Parsing.AlternativeParser(
9084 new System.Text.Parsing.AlternativeParser(
9085 new System.Text.Parsing.AlternativeParser(
9086 new System.Text.Parsing.AlternativeParser(
9087 new System.Text.Parsing.AlternativeParser(
9088 new System.Text.Parsing.AlternativeParser(
9089 new System.Text.Parsing.AlternativeParser(
9090 new System.Text.Parsing.AlternativeParser(
9091 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9092 new System.Text.Parsing.NonterminalParser(ToUtf32("UnaryInstruction"), ToUtf32("UnaryInstruction"), 2)),
9093 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9094 new System.Text.Parsing.NonterminalParser(ToUtf32("BinaryInstruction"), ToUtf32("BinaryInstruction"), 2))),
9095 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9096 new System.Text.Parsing.NonterminalParser(ToUtf32("ParamInstruction"), ToUtf32("ParamInstruction"), 2))),
9097 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
9098 new System.Text.Parsing.NonterminalParser(ToUtf32("LocalInstruction"), ToUtf32("LocalInstruction"), 2))),
9099 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
9100 new System.Text.Parsing.NonterminalParser(ToUtf32("LoadInstruction"), ToUtf32("LoadInstruction"), 2))),
9101 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
9102 new System.Text.Parsing.NonterminalParser(ToUtf32("ElemAddrInstruction"), ToUtf32("ElemAddrInstruction"), 2))),
9103 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
9104 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrOffsetInstruction"), ToUtf32("PtrOffsetInstruction"), 2))),
9105 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
9106 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrDiffInstruction"), ToUtf32("PtrDiffInstruction"), 2))),
9107 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
9108 new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionCallInstruction"), ToUtf32("FunctionCallInstruction"), 2))),
9109 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
9110 new System.Text.Parsing.NonterminalParser(ToUtf32("TrapInstruction"), ToUtf32("TrapInstruction"), 2)))));
9111 AddRule(new UnaryInstructionRule(ToUtf32("UnaryInstruction"), GetScope(), Domain()->GetNextRuleId(),
9112 new System.Text.Parsing.AlternativeParser(
9113 new System.Text.Parsing.AlternativeParser(
9114 new System.Text.Parsing.AlternativeParser(
9115 new System.Text.Parsing.AlternativeParser(
9116 new System.Text.Parsing.AlternativeParser(
9117 new System.Text.Parsing.AlternativeParser(
9118 new System.Text.Parsing.AlternativeParser(
9119 new System.Text.Parsing.AlternativeParser(
9120 new System.Text.Parsing.AlternativeParser(
9121 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9122 new System.Text.Parsing.NonterminalParser(ToUtf32("NotInstruction"), ToUtf32("NotInstruction"), 2)),
9123 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9124 new System.Text.Parsing.NonterminalParser(ToUtf32("NegInstruction"), ToUtf32("NegInstruction"), 2))),
9125 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9126 new System.Text.Parsing.NonterminalParser(ToUtf32("SignExtendInstruction"), ToUtf32("SignExtendInstruction"), 2))),
9127 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
9128 new System.Text.Parsing.NonterminalParser(ToUtf32("ZeroExtendInstruction"), ToUtf32("ZeroExtendInstruction"), 2))),
9129 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
9130 new System.Text.Parsing.NonterminalParser(ToUtf32("TruncateInstruction"), ToUtf32("TruncateInstruction"), 2))),
9131 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
9132 new System.Text.Parsing.NonterminalParser(ToUtf32("BitCastInstruction"), ToUtf32("BitCastInstruction"), 2))),
9133 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
9134 new System.Text.Parsing.NonterminalParser(ToUtf32("IntToFloatInstruction"), ToUtf32("IntToFloatInstruction"), 2))),
9135 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
9136 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatToIntInstruction"), ToUtf32("FloatToIntInstruction"), 2))),
9137 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
9138 new System.Text.Parsing.NonterminalParser(ToUtf32("IntToPtrInstruction"), ToUtf32("IntToPtrInstruction"), 2))),
9139 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
9140 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrToIntInstruction"), ToUtf32("PtrToIntInstruction"), 2)))));
9141 AddRule(new NotInstructionRule(ToUtf32("NotInstruction"), GetScope(), Domain()->GetNextRuleId(),
9142 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9143 new System.Text.Parsing.GroupingParser(
9144 new System.Text.Parsing.SequenceParser(
9145 new System.Text.Parsing.SequenceParser(
9146 new System.Text.Parsing.KeywordParser(ToUtf32("not")),
9147 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9148 new System.Text.Parsing.ExpectationParser(
9149 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9150 AddRule(new NegInstructionRule(ToUtf32("NegInstruction"), GetScope(), Domain()->GetNextRuleId(),
9151 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9152 new System.Text.Parsing.GroupingParser(
9153 new System.Text.Parsing.SequenceParser(
9154 new System.Text.Parsing.SequenceParser(
9155 new System.Text.Parsing.KeywordParser(ToUtf32("neg")),
9156 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9157 new System.Text.Parsing.ExpectationParser(
9158 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9159 AddRule(new SignExtendInstructionRule(ToUtf32("SignExtendInstruction"), GetScope(), Domain()->GetNextRuleId(),
9160 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9161 new System.Text.Parsing.GroupingParser(
9162 new System.Text.Parsing.SequenceParser(
9163 new System.Text.Parsing.SequenceParser(
9164 new System.Text.Parsing.KeywordParser(ToUtf32("signextend")),
9165 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9166 new System.Text.Parsing.ExpectationParser(
9167 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9168 AddRule(new ZeroExtendInstructionRule(ToUtf32("ZeroExtendInstruction"), GetScope(), Domain()->GetNextRuleId(),
9169 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9170 new System.Text.Parsing.GroupingParser(
9171 new System.Text.Parsing.SequenceParser(
9172 new System.Text.Parsing.SequenceParser(
9173 new System.Text.Parsing.KeywordParser(ToUtf32("zeroextend")),
9174 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9175 new System.Text.Parsing.ExpectationParser(
9176 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9177 AddRule(new TruncateInstructionRule(ToUtf32("TruncateInstruction"), GetScope(), Domain()->GetNextRuleId(),
9178 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9179 new System.Text.Parsing.GroupingParser(
9180 new System.Text.Parsing.SequenceParser(
9181 new System.Text.Parsing.SequenceParser(
9182 new System.Text.Parsing.KeywordParser(ToUtf32("truncate")),
9183 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9184 new System.Text.Parsing.ExpectationParser(
9185 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9186 AddRule(new BitCastInstructionRule(ToUtf32("BitCastInstruction"), GetScope(), Domain()->GetNextRuleId(),
9187 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9188 new System.Text.Parsing.GroupingParser(
9189 new System.Text.Parsing.SequenceParser(
9190 new System.Text.Parsing.SequenceParser(
9191 new System.Text.Parsing.KeywordParser(ToUtf32("bitcast")),
9192 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9193 new System.Text.Parsing.ExpectationParser(
9194 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9195 AddRule(new IntToFloatInstructionRule(ToUtf32("IntToFloatInstruction"), GetScope(), Domain()->GetNextRuleId(),
9196 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9197 new System.Text.Parsing.GroupingParser(
9198 new System.Text.Parsing.SequenceParser(
9199 new System.Text.Parsing.SequenceParser(
9200 new System.Text.Parsing.KeywordParser(ToUtf32("inttofloat")),
9201 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9202 new System.Text.Parsing.ExpectationParser(
9203 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9204 AddRule(new FloatToIntInstructionRule(ToUtf32("FloatToIntInstruction"), GetScope(), Domain()->GetNextRuleId(),
9205 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9206 new System.Text.Parsing.GroupingParser(
9207 new System.Text.Parsing.SequenceParser(
9208 new System.Text.Parsing.SequenceParser(
9209 new System.Text.Parsing.KeywordParser(ToUtf32("floattoint")),
9210 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9211 new System.Text.Parsing.ExpectationParser(
9212 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9213 AddRule(new IntToPtrInstructionRule(ToUtf32("IntToPtrInstruction"), GetScope(), Domain()->GetNextRuleId(),
9214 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9215 new System.Text.Parsing.GroupingParser(
9216 new System.Text.Parsing.SequenceParser(
9217 new System.Text.Parsing.SequenceParser(
9218 new System.Text.Parsing.KeywordParser(ToUtf32("inttoptr")),
9219 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9220 new System.Text.Parsing.ExpectationParser(
9221 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9222 AddRule(new PtrToIntInstructionRule(ToUtf32("PtrToIntInstruction"), GetScope(), Domain()->GetNextRuleId(),
9223 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9224 new System.Text.Parsing.GroupingParser(
9225 new System.Text.Parsing.SequenceParser(
9226 new System.Text.Parsing.SequenceParser(
9227 new System.Text.Parsing.KeywordParser(ToUtf32("ptrtoint")),
9228 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9229 new System.Text.Parsing.ExpectationParser(
9230 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
9231 AddRule(new BinaryInstructionRule(ToUtf32("BinaryInstruction"), GetScope(), Domain()->GetNextRuleId(),
9232 new System.Text.Parsing.AlternativeParser(
9233 new System.Text.Parsing.AlternativeParser(
9234 new System.Text.Parsing.AlternativeParser(
9235 new System.Text.Parsing.AlternativeParser(
9236 new System.Text.Parsing.AlternativeParser(
9237 new System.Text.Parsing.AlternativeParser(
9238 new System.Text.Parsing.AlternativeParser(
9239 new System.Text.Parsing.AlternativeParser(
9240 new System.Text.Parsing.AlternativeParser(
9241 new System.Text.Parsing.AlternativeParser(
9242 new System.Text.Parsing.AlternativeParser(
9243 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9244 new System.Text.Parsing.NonterminalParser(ToUtf32("AddInstruction"), ToUtf32("AddInstruction"), 2)),
9245 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9246 new System.Text.Parsing.NonterminalParser(ToUtf32("SubInstruction"), ToUtf32("SubInstruction"), 2))),
9247 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9248 new System.Text.Parsing.NonterminalParser(ToUtf32("MulInstruction"), ToUtf32("MulInstruction"), 2))),
9249 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
9250 new System.Text.Parsing.NonterminalParser(ToUtf32("DivInstruction"), ToUtf32("DivInstruction"), 2))),
9251 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
9252 new System.Text.Parsing.NonterminalParser(ToUtf32("ModInstruction"), ToUtf32("ModInstruction"), 2))),
9253 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
9254 new System.Text.Parsing.NonterminalParser(ToUtf32("AndInstruction"), ToUtf32("AndInstruction"), 2))),
9255 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
9256 new System.Text.Parsing.NonterminalParser(ToUtf32("OrInstruction"), ToUtf32("OrInstruction"), 2))),
9257 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
9258 new System.Text.Parsing.NonterminalParser(ToUtf32("XorInstruction"), ToUtf32("XorInstruction"), 2))),
9259 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
9260 new System.Text.Parsing.NonterminalParser(ToUtf32("ShlInstruction"), ToUtf32("ShlInstruction"), 2))),
9261 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
9262 new System.Text.Parsing.NonterminalParser(ToUtf32("ShrInstruction"), ToUtf32("ShrInstruction"), 2))),
9263 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
9264 new System.Text.Parsing.NonterminalParser(ToUtf32("EqualInstruction"), ToUtf32("EqualInstruction"), 2))),
9265 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
9266 new System.Text.Parsing.NonterminalParser(ToUtf32("LessInstruction"), ToUtf32("LessInstruction"), 2)))));
9267 AddRule(new AddInstructionRule(ToUtf32("AddInstruction"), GetScope(), Domain()->GetNextRuleId(),
9268 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9269 new System.Text.Parsing.GroupingParser(
9270 new System.Text.Parsing.SequenceParser(
9271 new System.Text.Parsing.SequenceParser(
9272 new System.Text.Parsing.SequenceParser(
9273 new System.Text.Parsing.SequenceParser(
9274 new System.Text.Parsing.KeywordParser(ToUtf32("add")),
9275 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9276 new System.Text.Parsing.ExpectationParser(
9277 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9278 new System.Text.Parsing.ExpectationParser(
9279 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9280 new System.Text.Parsing.ExpectationParser(
9281 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9282 AddRule(new SubInstructionRule(ToUtf32("SubInstruction"), GetScope(), Domain()->GetNextRuleId(),
9283 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9284 new System.Text.Parsing.GroupingParser(
9285 new System.Text.Parsing.SequenceParser(
9286 new System.Text.Parsing.SequenceParser(
9287 new System.Text.Parsing.SequenceParser(
9288 new System.Text.Parsing.SequenceParser(
9289 new System.Text.Parsing.KeywordParser(ToUtf32("sub")),
9290 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9291 new System.Text.Parsing.ExpectationParser(
9292 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9293 new System.Text.Parsing.ExpectationParser(
9294 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9295 new System.Text.Parsing.ExpectationParser(
9296 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9297 AddRule(new MulInstructionRule(ToUtf32("MulInstruction"), GetScope(), Domain()->GetNextRuleId(),
9298 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9299 new System.Text.Parsing.GroupingParser(
9300 new System.Text.Parsing.SequenceParser(
9301 new System.Text.Parsing.SequenceParser(
9302 new System.Text.Parsing.SequenceParser(
9303 new System.Text.Parsing.SequenceParser(
9304 new System.Text.Parsing.KeywordParser(ToUtf32("mul")),
9305 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9306 new System.Text.Parsing.ExpectationParser(
9307 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9308 new System.Text.Parsing.ExpectationParser(
9309 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9310 new System.Text.Parsing.ExpectationParser(
9311 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9312 AddRule(new DivInstructionRule(ToUtf32("DivInstruction"), GetScope(), Domain()->GetNextRuleId(),
9313 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9314 new System.Text.Parsing.GroupingParser(
9315 new System.Text.Parsing.SequenceParser(
9316 new System.Text.Parsing.SequenceParser(
9317 new System.Text.Parsing.SequenceParser(
9318 new System.Text.Parsing.SequenceParser(
9319 new System.Text.Parsing.KeywordParser(ToUtf32("div")),
9320 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9321 new System.Text.Parsing.ExpectationParser(
9322 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9323 new System.Text.Parsing.ExpectationParser(
9324 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9325 new System.Text.Parsing.ExpectationParser(
9326 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9327 AddRule(new ModInstructionRule(ToUtf32("ModInstruction"), GetScope(), Domain()->GetNextRuleId(),
9328 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9329 new System.Text.Parsing.GroupingParser(
9330 new System.Text.Parsing.SequenceParser(
9331 new System.Text.Parsing.SequenceParser(
9332 new System.Text.Parsing.SequenceParser(
9333 new System.Text.Parsing.SequenceParser(
9334 new System.Text.Parsing.KeywordParser(ToUtf32("mod")),
9335 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9336 new System.Text.Parsing.ExpectationParser(
9337 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9338 new System.Text.Parsing.ExpectationParser(
9339 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9340 new System.Text.Parsing.ExpectationParser(
9341 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9342 AddRule(new AndInstructionRule(ToUtf32("AndInstruction"), GetScope(), Domain()->GetNextRuleId(),
9343 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9344 new System.Text.Parsing.GroupingParser(
9345 new System.Text.Parsing.SequenceParser(
9346 new System.Text.Parsing.SequenceParser(
9347 new System.Text.Parsing.SequenceParser(
9348 new System.Text.Parsing.SequenceParser(
9349 new System.Text.Parsing.KeywordParser(ToUtf32("and")),
9350 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9351 new System.Text.Parsing.ExpectationParser(
9352 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9353 new System.Text.Parsing.ExpectationParser(
9354 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9355 new System.Text.Parsing.ExpectationParser(
9356 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9357 AddRule(new OrInstructionRule(ToUtf32("OrInstruction"), GetScope(), Domain()->GetNextRuleId(),
9358 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9359 new System.Text.Parsing.GroupingParser(
9360 new System.Text.Parsing.SequenceParser(
9361 new System.Text.Parsing.SequenceParser(
9362 new System.Text.Parsing.SequenceParser(
9363 new System.Text.Parsing.SequenceParser(
9364 new System.Text.Parsing.KeywordParser(ToUtf32("or")),
9365 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9366 new System.Text.Parsing.ExpectationParser(
9367 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9368 new System.Text.Parsing.ExpectationParser(
9369 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9370 new System.Text.Parsing.ExpectationParser(
9371 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9372 AddRule(new XorInstructionRule(ToUtf32("XorInstruction"), GetScope(), Domain()->GetNextRuleId(),
9373 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9374 new System.Text.Parsing.GroupingParser(
9375 new System.Text.Parsing.SequenceParser(
9376 new System.Text.Parsing.SequenceParser(
9377 new System.Text.Parsing.SequenceParser(
9378 new System.Text.Parsing.SequenceParser(
9379 new System.Text.Parsing.KeywordParser(ToUtf32("xor")),
9380 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9381 new System.Text.Parsing.ExpectationParser(
9382 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9383 new System.Text.Parsing.ExpectationParser(
9384 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9385 new System.Text.Parsing.ExpectationParser(
9386 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9387 AddRule(new ShlInstructionRule(ToUtf32("ShlInstruction"), GetScope(), Domain()->GetNextRuleId(),
9388 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9389 new System.Text.Parsing.GroupingParser(
9390 new System.Text.Parsing.SequenceParser(
9391 new System.Text.Parsing.SequenceParser(
9392 new System.Text.Parsing.SequenceParser(
9393 new System.Text.Parsing.SequenceParser(
9394 new System.Text.Parsing.KeywordParser(ToUtf32("shl")),
9395 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9396 new System.Text.Parsing.ExpectationParser(
9397 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9398 new System.Text.Parsing.ExpectationParser(
9399 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9400 new System.Text.Parsing.ExpectationParser(
9401 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9402 AddRule(new ShrInstructionRule(ToUtf32("ShrInstruction"), GetScope(), Domain()->GetNextRuleId(),
9403 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9404 new System.Text.Parsing.GroupingParser(
9405 new System.Text.Parsing.SequenceParser(
9406 new System.Text.Parsing.SequenceParser(
9407 new System.Text.Parsing.SequenceParser(
9408 new System.Text.Parsing.SequenceParser(
9409 new System.Text.Parsing.KeywordParser(ToUtf32("shr")),
9410 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9411 new System.Text.Parsing.ExpectationParser(
9412 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9413 new System.Text.Parsing.ExpectationParser(
9414 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9415 new System.Text.Parsing.ExpectationParser(
9416 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9417 AddRule(new EqualInstructionRule(ToUtf32("EqualInstruction"), GetScope(), Domain()->GetNextRuleId(),
9418 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9419 new System.Text.Parsing.GroupingParser(
9420 new System.Text.Parsing.SequenceParser(
9421 new System.Text.Parsing.SequenceParser(
9422 new System.Text.Parsing.SequenceParser(
9423 new System.Text.Parsing.SequenceParser(
9424 new System.Text.Parsing.KeywordParser(ToUtf32("equal")),
9425 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9426 new System.Text.Parsing.ExpectationParser(
9427 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9428 new System.Text.Parsing.ExpectationParser(
9429 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9430 new System.Text.Parsing.ExpectationParser(
9431 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9432 AddRule(new LessInstructionRule(ToUtf32("LessInstruction"), GetScope(), Domain()->GetNextRuleId(),
9433 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9434 new System.Text.Parsing.GroupingParser(
9435 new System.Text.Parsing.SequenceParser(
9436 new System.Text.Parsing.SequenceParser(
9437 new System.Text.Parsing.SequenceParser(
9438 new System.Text.Parsing.SequenceParser(
9439 new System.Text.Parsing.KeywordParser(ToUtf32("less")),
9440 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9441 new System.Text.Parsing.ExpectationParser(
9442 new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))),
9443 new System.Text.Parsing.ExpectationParser(
9444 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9445 new System.Text.Parsing.ExpectationParser(
9446 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
9447 AddRule(new ParamInstructionRule(ToUtf32("ParamInstruction"), GetScope(), Domain()->GetNextRuleId(),
9448 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9449 new System.Text.Parsing.KeywordParser(ToUtf32("param")))));
9450 AddRule(new LocalInstructionRule(ToUtf32("LocalInstruction"), GetScope(), Domain()->GetNextRuleId(),
9451 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9452 new System.Text.Parsing.GroupingParser(
9453 new System.Text.Parsing.SequenceParser(
9454 new System.Text.Parsing.SequenceParser(
9455 new System.Text.Parsing.KeywordParser(ToUtf32("local")),
9456 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9457 new System.Text.Parsing.ExpectationParser(
9458 new System.Text.Parsing.NonterminalParser(ToUtf32("localType"), ToUtf32("TypeExpr"), 1)))))));
9459 AddRule(new LoadInstructionRule(ToUtf32("LoadInstruction"), GetScope(), Domain()->GetNextRuleId(),
9460 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9461 new System.Text.Parsing.GroupingParser(
9462 new System.Text.Parsing.SequenceParser(
9463 new System.Text.Parsing.SequenceParser(
9464 new System.Text.Parsing.KeywordParser(ToUtf32("load")),
9465 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9466 new System.Text.Parsing.ExpectationParser(
9467 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1)))))));
9468 AddRule(new ElemAddrInstructionRule(ToUtf32("ElemAddrInstruction"), GetScope(), Domain()->GetNextRuleId(),
9469 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9470 new System.Text.Parsing.GroupingParser(
9471 new System.Text.Parsing.SequenceParser(
9472 new System.Text.Parsing.SequenceParser(
9473 new System.Text.Parsing.SequenceParser(
9474 new System.Text.Parsing.SequenceParser(
9475 new System.Text.Parsing.KeywordParser(ToUtf32("elemaddr")),
9476 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9477 new System.Text.Parsing.ExpectationParser(
9478 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))),
9479 new System.Text.Parsing.ExpectationParser(
9480 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9481 new System.Text.Parsing.ExpectationParser(
9482 new System.Text.Parsing.NonterminalParser(ToUtf32("index"), ToUtf32("Operand"), 1)))))));
9483 AddRule(new PtrOffsetInstructionRule(ToUtf32("PtrOffsetInstruction"), GetScope(), Domain()->GetNextRuleId(),
9484 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9485 new System.Text.Parsing.GroupingParser(
9486 new System.Text.Parsing.SequenceParser(
9487 new System.Text.Parsing.SequenceParser(
9488 new System.Text.Parsing.SequenceParser(
9489 new System.Text.Parsing.SequenceParser(
9490 new System.Text.Parsing.KeywordParser(ToUtf32("ptroffset")),
9491 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9492 new System.Text.Parsing.ExpectationParser(
9493 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))),
9494 new System.Text.Parsing.ExpectationParser(
9495 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9496 new System.Text.Parsing.ExpectationParser(
9497 new System.Text.Parsing.NonterminalParser(ToUtf32("offset"), ToUtf32("Operand"), 1)))))));
9498 AddRule(new PtrDiffInstructionRule(ToUtf32("PtrDiffInstruction"), GetScope(), Domain()->GetNextRuleId(),
9499 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9500 new System.Text.Parsing.GroupingParser(
9501 new System.Text.Parsing.SequenceParser(
9502 new System.Text.Parsing.SequenceParser(
9503 new System.Text.Parsing.SequenceParser(
9504 new System.Text.Parsing.SequenceParser(
9505 new System.Text.Parsing.KeywordParser(ToUtf32("ptrdiff")),
9506 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9507 new System.Text.Parsing.ExpectationParser(
9508 new System.Text.Parsing.NonterminalParser(ToUtf32("leftPtr"), ToUtf32("Operand"), 1))),
9509 new System.Text.Parsing.ExpectationParser(
9510 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9511 new System.Text.Parsing.ExpectationParser(
9512 new System.Text.Parsing.NonterminalParser(ToUtf32("rightPtr"), ToUtf32("Operand"), 1)))))));
9513 AddRule(new FunctionCallInstructionRule(ToUtf32("FunctionCallInstruction"), GetScope(), Domain()->GetNextRuleId(),
9514 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9515 new System.Text.Parsing.GroupingParser(
9516 new System.Text.Parsing.SequenceParser(
9517 new System.Text.Parsing.SequenceParser(
9518 new System.Text.Parsing.SequenceParser(
9519 new System.Text.Parsing.SequenceParser(
9520 new System.Text.Parsing.KeywordParser(ToUtf32("call")),
9521 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9522 new System.Text.Parsing.ExpectationParser(
9523 new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))),
9524 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9525 new System.Text.Parsing.ExpectationParser(
9526 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
9527 AddRule(new TrapInstructionRule(ToUtf32("TrapInstruction"), GetScope(), Domain()->GetNextRuleId(),
9528 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9529 new System.Text.Parsing.GroupingParser(
9530 new System.Text.Parsing.SequenceParser(
9531 new System.Text.Parsing.SequenceParser(
9532 new System.Text.Parsing.SequenceParser(
9533 new System.Text.Parsing.SequenceParser(
9534 new System.Text.Parsing.SequenceParser(
9535 new System.Text.Parsing.SequenceParser(
9536 new System.Text.Parsing.SequenceParser(
9537 new System.Text.Parsing.SequenceParser(
9538 new System.Text.Parsing.SequenceParser(
9539 new System.Text.Parsing.SequenceParser(
9540 new System.Text.Parsing.SequenceParser(
9541 new System.Text.Parsing.SequenceParser(
9542 new System.Text.Parsing.KeywordParser(ToUtf32("trap")),
9543 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9544 new System.Text.Parsing.ExpectationParser(
9545 new System.Text.Parsing.NonterminalParser(ToUtf32("type1"), ToUtf32("TypeExpr"), 1))),
9546 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9547 new System.Text.Parsing.ExpectationParser(
9548 new System.Text.Parsing.NonterminalParser(ToUtf32("val1"), ToUtf32("Value"), 2))),
9549 new System.Text.Parsing.ExpectationParser(
9550 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9551 new System.Text.Parsing.ExpectationParser(
9552 new System.Text.Parsing.NonterminalParser(ToUtf32("type2"), ToUtf32("TypeExpr"), 1))),
9553 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9554 new System.Text.Parsing.ExpectationParser(
9555 new System.Text.Parsing.NonterminalParser(ToUtf32("val2"), ToUtf32("Value"), 2))),
9556 new System.Text.Parsing.ExpectationParser(
9557 new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))),
9558 new System.Text.Parsing.ExpectationParser(
9559 new System.Text.Parsing.NonterminalParser(ToUtf32("type3"), ToUtf32("TypeExpr"), 1))),
9560 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9561 new System.Text.Parsing.ExpectationParser(
9562 new System.Text.Parsing.NonterminalParser(ToUtf32("val3"), ToUtf32("Value"), 2)))))));
9563 AddRule(new OperandRule(ToUtf32("Operand"), GetScope(), Domain()->GetNextRuleId(),
9564 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9565 new System.Text.Parsing.GroupingParser(
9566 new System.Text.Parsing.SequenceParser(
9567 new System.Text.Parsing.SequenceParser(
9568 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
9569 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9570 new System.Text.Parsing.ExpectationParser(
9571 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2)))))));
9572 AddRule(new LabelRule(ToUtf32("Label"), GetScope(), Domain()->GetNextRuleId(),
9573 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9574 new System.Text.Parsing.TokenParser(
9575 new System.Text.Parsing.SequenceParser(
9576 new System.Text.Parsing.CharParser('@'),
9577 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
9578 AddRule(new ValueRule(ToUtf32("Value"), GetScope(), Domain()->GetNextRuleId(),
9579 new System.Text.Parsing.AlternativeParser(
9580 new System.Text.Parsing.AlternativeParser(
9581 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9582 new System.Text.Parsing.NonterminalParser(ToUtf32("IdValue"), ToUtf32("IdValue"), 2)),
9583 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9584 new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolValue"), ToUtf32("SymbolValue"), 2))),
9585 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9586 new System.Text.Parsing.NonterminalParser(ToUtf32("LiteralValue"), ToUtf32("LiteralValue"), 2)))));
9587 AddRule(new IdValueRule(ToUtf32("IdValue"), GetScope(), Domain()->GetNextRuleId(),
9588 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9589 new System.Text.Parsing.GroupingParser(
9590 new System.Text.Parsing.SequenceParser(
9591 new System.Text.Parsing.CharParser('$'),
9592 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
9593 AddRule(new SymbolValueRule(ToUtf32("SymbolValue"), GetScope(), Domain()->GetNextRuleId(),
9594 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9595 new System.Text.Parsing.TokenParser(
9596 new System.Text.Parsing.SequenceParser(
9597 new System.Text.Parsing.CharParser('@'),
9598 new System.Text.Parsing.NonterminalParser(ToUtf32("identifier"), ToUtf32("identifier"), 0))))));
9599 AddRule(new LiteralValueRule(ToUtf32("LiteralValue"), GetScope(), Domain()->GetNextRuleId(),
9600 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9601 new System.Text.Parsing.GroupingParser(
9602 new System.Text.Parsing.PositiveParser(
9603 new System.Text.Parsing.TokenParser(
9604 new System.Text.Parsing.DifferenceParser(
9605 new System.Text.Parsing.AnyCharParser(),
9606 new System.Text.Parsing.GroupingParser(
9607 new System.Text.Parsing.AlternativeParser(
9608 new System.Text.Parsing.AlternativeParser(
9609 new System.Text.Parsing.CharParser(','),
9610 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9611 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0))))))))));
9612 AddRule(new System.Text.Parsing.RuleParser(ToUtf32("S"), GetScope(), Domain()->GetNextRuleId(),
9613 new System.Text.Parsing.PositiveParser(
9614 new System.Text.Parsing.CharSetParser(ToUtf32(" \t")))));
9615 AddRule(new System.Text.Parsing.RuleParser(ToUtf32("Comma"), GetScope(), Domain()->GetNextRuleId(),
9616 new System.Text.Parsing.SequenceParser(
9617 new System.Text.Parsing.SequenceParser(
9618 new System.Text.Parsing.OptionalParser(
9619 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)),
9620 new System.Text.Parsing.CharParser(',')),
9621 new System.Text.Parsing.OptionalParser(
9622 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))));
9623 AddRule(new TypeDeclarationRule(ToUtf32("TypeDeclaration"), GetScope(), Domain()->GetNextRuleId(),
9624 new System.Text.Parsing.SequenceParser(
9625 new System.Text.Parsing.SequenceParser(
9626 new System.Text.Parsing.SequenceParser(
9627 new System.Text.Parsing.NonterminalParser(ToUtf32("typeId"), ToUtf32("StrTypeId"), 1),
9628 new System.Text.Parsing.ExpectationParser(
9629 new System.Text.Parsing.CharParser('='))),
9630 new System.Text.Parsing.ExpectationParser(
9631 new System.Text.Parsing.KeywordParser(ToUtf32("type")))),
9632 new System.Text.Parsing.GroupingParser(
9633 new System.Text.Parsing.AlternativeParser(
9634 new System.Text.Parsing.AlternativeParser(
9635 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureType"), ToUtf32("StructureType"), 2),
9636 new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayType"), ToUtf32("ArrayType"), 2)),
9637 new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionType"), ToUtf32("FunctionType"), 2))))));
9638 AddRule(new StructureTypeRule(ToUtf32("StructureType"), GetScope(), Domain()->GetNextRuleId(),
9639 new System.Text.Parsing.SequenceParser(
9640 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9641 new System.Text.Parsing.GroupingParser(
9642 new System.Text.Parsing.SequenceParser(
9643 new System.Text.Parsing.SequenceParser(
9644 new System.Text.Parsing.CharParser('{'),
9645 new System.Text.Parsing.OptionalParser(
9646 new System.Text.Parsing.GroupingParser(
9647 new System.Text.Parsing.ListParser(
9648 new System.Text.Parsing.GroupingParser(
9649 new System.Text.Parsing.SequenceParser(
9650 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9651 new System.Text.Parsing.ExpectationParser(
9652 new System.Text.Parsing.NonterminalParser(ToUtf32("StrTypeId"), ToUtf32("StrTypeId"), 1))),
9653 new System.Text.Parsing.OptionalParser(
9654 new System.Text.Parsing.GroupingParser(
9655 new System.Text.Parsing.SequenceParser(
9656 new System.Text.Parsing.SequenceParser(
9657 new System.Text.Parsing.SequenceParser(
9658 new System.Text.Parsing.CharParser(':'),
9659 new System.Text.Parsing.StringParser(ToUtf32("offset"))),
9660 new System.Text.Parsing.CharParser('=')),
9661 new System.Text.Parsing.NonterminalParser(ToUtf32("long"), ToUtf32("long"), 0)))))),
9662 new System.Text.Parsing.CharParser(','))))),
9663 new System.Text.Parsing.ExpectationParser(
9664 new System.Text.Parsing.CharParser('}'))))),
9665 new System.Text.Parsing.OptionalParser(
9666 new System.Text.Parsing.GroupingParser(
9667 new System.Text.Parsing.SequenceParser(
9668 new System.Text.Parsing.SequenceParser(
9669 new System.Text.Parsing.SequenceParser(
9670 new System.Text.Parsing.SequenceParser(
9671 new System.Text.Parsing.SequenceParser(
9672 new System.Text.Parsing.SequenceParser(
9673 new System.Text.Parsing.KeywordParser(ToUtf32("size")),
9674 new System.Text.Parsing.CharParser('=')),
9675 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)),
9676 new System.Text.Parsing.CharParser(',')),
9677 new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))),
9678 new System.Text.Parsing.CharParser('=')),
9679 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
9680 AddRule(new ArrayTypeRule(ToUtf32("ArrayType"), GetScope(), Domain()->GetNextRuleId(),
9681 new System.Text.Parsing.SequenceParser(
9682 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9683 new System.Text.Parsing.GroupingParser(
9684 new System.Text.Parsing.SequenceParser(
9685 new System.Text.Parsing.SequenceParser(
9686 new System.Text.Parsing.SequenceParser(
9687 new System.Text.Parsing.SequenceParser(
9688 new System.Text.Parsing.CharParser('['),
9689 new System.Text.Parsing.ExpectationParser(
9690 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("long"), 0))),
9691 new System.Text.Parsing.ExpectationParser(
9692 new System.Text.Parsing.CharParser('x'))),
9693 new System.Text.Parsing.ExpectationParser(
9694 new System.Text.Parsing.NonterminalParser(ToUtf32("elementTypeId"), ToUtf32("StrTypeId"), 1))),
9695 new System.Text.Parsing.ExpectationParser(
9696 new System.Text.Parsing.CharParser(']'))))),
9697 new System.Text.Parsing.OptionalParser(
9698 new System.Text.Parsing.GroupingParser(
9699 new System.Text.Parsing.SequenceParser(
9700 new System.Text.Parsing.SequenceParser(
9701 new System.Text.Parsing.SequenceParser(
9702 new System.Text.Parsing.SequenceParser(
9703 new System.Text.Parsing.SequenceParser(
9704 new System.Text.Parsing.SequenceParser(
9705 new System.Text.Parsing.KeywordParser(ToUtf32("size")),
9706 new System.Text.Parsing.CharParser('=')),
9707 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)),
9708 new System.Text.Parsing.CharParser(',')),
9709 new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))),
9710 new System.Text.Parsing.CharParser('=')),
9711 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
9712 AddRule(new FunctionTypeRule(ToUtf32("FunctionType"), GetScope(), Domain()->GetNextRuleId(),
9713 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9714 new System.Text.Parsing.GroupingParser(
9715 new System.Text.Parsing.SequenceParser(
9716 new System.Text.Parsing.SequenceParser(
9717 new System.Text.Parsing.SequenceParser(
9718 new System.Text.Parsing.SequenceParser(
9719 new System.Text.Parsing.KeywordParser(ToUtf32("function")),
9720 new System.Text.Parsing.ExpectationParser(
9721 new System.Text.Parsing.NonterminalParser(ToUtf32("returnTypeId"), ToUtf32("StrTypeId"), 1))),
9722 new System.Text.Parsing.ExpectationParser(
9723 new System.Text.Parsing.CharParser('('))),
9724 new System.Text.Parsing.OptionalParser(
9725 new System.Text.Parsing.GroupingParser(
9726 new System.Text.Parsing.ListParser(
9727 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9728 new System.Text.Parsing.NonterminalParser(ToUtf32("paramType"), ToUtf32("StrTypeId"), 1)),
9729 new System.Text.Parsing.CharParser(','))))),
9730 new System.Text.Parsing.ExpectationParser(
9731 new System.Text.Parsing.CharParser(')')))))));
9732 AddRule(new StrTypeIdRule(ToUtf32("StrTypeId"), GetScope(), Domain()->GetNextRuleId(),
9733 new System.Text.Parsing.SequenceParser(
9734 new System.Text.Parsing.GroupingParser(
9735 new System.Text.Parsing.AlternativeParser(
9736 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9737 new System.Text.Parsing.TokenParser(
9738 new System.Text.Parsing.SequenceParser(
9739 new System.Text.Parsing.StringParser(ToUtf32("$T")),
9740 new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0)))),
9741 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9742 new System.Text.Parsing.GroupingParser(
9743 new System.Text.Parsing.KeywordListParser(ToUtf32("identifier"), keywords0))))),
9744 new System.Text.Parsing.KleeneStarParser(
9745 new System.Text.Parsing.GroupingParser(
9746 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9747 new System.Text.Parsing.GroupingParser(
9748 new System.Text.Parsing.CharParser('*'))))))));
9749 AddRule(new TypeExprRule(ToUtf32("TypeExpr"), GetScope(), Domain()->GetNextRuleId(),
9750 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9751 new System.Text.Parsing.NonterminalParser(ToUtf32("PostfixTypeExpr"), ToUtf32("PostfixTypeExpr"), 1))));
9752 AddRule(new PostfixTypeExprRule(ToUtf32("PostfixTypeExpr"), GetScope(), Domain()->GetNextRuleId(),
9753 new System.Text.Parsing.SequenceParser(
9754 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9755 new System.Text.Parsing.NonterminalParser(ToUtf32("PrimaryTypeExpr"), ToUtf32("PrimaryTypeExpr"), 1)),
9756 new System.Text.Parsing.KleeneStarParser(
9757 new System.Text.Parsing.GroupingParser(
9758 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9759 new System.Text.Parsing.CharParser('*')))))));
9760 AddRule(new PrimaryTypeExprRule(ToUtf32("PrimaryTypeExpr"), GetScope(), Domain()->GetNextRuleId(),
9761 new System.Text.Parsing.AlternativeParser(
9762 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9763 new System.Text.Parsing.NonterminalParser(ToUtf32("TypeId"), ToUtf32("TypeId"), 1)),
9764 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9765 new System.Text.Parsing.NonterminalParser(ToUtf32("PrimitiveType"), ToUtf32("PrimitiveType"), 1)))));
9766 AddRule(new TypeIdRule(ToUtf32("TypeId"), GetScope(), Domain()->GetNextRuleId(),
9767 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9768 new System.Text.Parsing.TokenParser(
9769 new System.Text.Parsing.SequenceParser(
9770 new System.Text.Parsing.StringParser(ToUtf32("$T")),
9771 new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0))))));
9772 AddRule(new PrimitiveTypeRule(ToUtf32("PrimitiveType"), GetScope(), Domain()->GetNextRuleId(),
9773 new System.Text.Parsing.AlternativeParser(
9774 new System.Text.Parsing.AlternativeParser(
9775 new System.Text.Parsing.AlternativeParser(
9776 new System.Text.Parsing.AlternativeParser(
9777 new System.Text.Parsing.AlternativeParser(
9778 new System.Text.Parsing.AlternativeParser(
9779 new System.Text.Parsing.AlternativeParser(
9780 new System.Text.Parsing.AlternativeParser(
9781 new System.Text.Parsing.AlternativeParser(
9782 new System.Text.Parsing.AlternativeParser(
9783 new System.Text.Parsing.AlternativeParser(
9784 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9785 new System.Text.Parsing.NonterminalParser(ToUtf32("VoidType"), ToUtf32("VoidType"), 1)),
9786 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9787 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolType"), ToUtf32("BoolType"), 1))),
9788 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9789 new System.Text.Parsing.NonterminalParser(ToUtf32("SByteType"), ToUtf32("SByteType"), 1))),
9790 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
9791 new System.Text.Parsing.NonterminalParser(ToUtf32("ByteType"), ToUtf32("ByteType"), 1))),
9792 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
9793 new System.Text.Parsing.NonterminalParser(ToUtf32("ShortType"), ToUtf32("ShortType"), 1))),
9794 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
9795 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortType"), ToUtf32("UShortType"), 1))),
9796 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
9797 new System.Text.Parsing.NonterminalParser(ToUtf32("IntType"), ToUtf32("IntType"), 1))),
9798 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
9799 new System.Text.Parsing.NonterminalParser(ToUtf32("UIntType"), ToUtf32("UIntType"), 1))),
9800 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
9801 new System.Text.Parsing.NonterminalParser(ToUtf32("LongType"), ToUtf32("LongType"), 1))),
9802 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
9803 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongType"), ToUtf32("ULongType"), 1))),
9804 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
9805 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatType"), ToUtf32("FloatType"), 1))),
9806 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
9807 new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleType"), ToUtf32("DoubleType"), 1)))));
9808 AddRule(new VoidTypeRule(ToUtf32("VoidType"), GetScope(), Domain()->GetNextRuleId(),
9809 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9810 new System.Text.Parsing.KeywordParser(ToUtf32("void")))));
9811 AddRule(new BoolTypeRule(ToUtf32("BoolType"), GetScope(), Domain()->GetNextRuleId(),
9812 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9813 new System.Text.Parsing.KeywordParser(ToUtf32("bool")))));
9814 AddRule(new SByteTypeRule(ToUtf32("SByteType"), GetScope(), Domain()->GetNextRuleId(),
9815 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9816 new System.Text.Parsing.KeywordParser(ToUtf32("sbyte")))));
9817 AddRule(new ByteTypeRule(ToUtf32("ByteType"), GetScope(), Domain()->GetNextRuleId(),
9818 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9819 new System.Text.Parsing.KeywordParser(ToUtf32("byte")))));
9820 AddRule(new ShortTypeRule(ToUtf32("ShortType"), GetScope(), Domain()->GetNextRuleId(),
9821 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9822 new System.Text.Parsing.KeywordParser(ToUtf32("short")))));
9823 AddRule(new UShortTypeRule(ToUtf32("UShortType"), GetScope(), Domain()->GetNextRuleId(),
9824 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9825 new System.Text.Parsing.KeywordParser(ToUtf32("ushort")))));
9826 AddRule(new IntTypeRule(ToUtf32("IntType"), GetScope(), Domain()->GetNextRuleId(),
9827 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9828 new System.Text.Parsing.KeywordParser(ToUtf32("int")))));
9829 AddRule(new UIntTypeRule(ToUtf32("UIntType"), GetScope(), Domain()->GetNextRuleId(),
9830 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9831 new System.Text.Parsing.KeywordParser(ToUtf32("uint")))));
9832 AddRule(new LongTypeRule(ToUtf32("LongType"), GetScope(), Domain()->GetNextRuleId(),
9833 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9834 new System.Text.Parsing.KeywordParser(ToUtf32("long")))));
9835 AddRule(new ULongTypeRule(ToUtf32("ULongType"), GetScope(), Domain()->GetNextRuleId(),
9836 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9837 new System.Text.Parsing.KeywordParser(ToUtf32("ulong")))));
9838 AddRule(new FloatTypeRule(ToUtf32("FloatType"), GetScope(), Domain()->GetNextRuleId(),
9839 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9840 new System.Text.Parsing.KeywordParser(ToUtf32("float")))));
9841 AddRule(new DoubleTypeRule(ToUtf32("DoubleType"), GetScope(), Domain()->GetNextRuleId(),
9842 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9843 new System.Text.Parsing.KeywordParser(ToUtf32("double")))));
9844 AddRule(new DataDefinitionRule(ToUtf32("DataDefinition"), GetScope(), Domain()->GetNextRuleId(),
9845 new System.Text.Parsing.SequenceParser(
9846 new System.Text.Parsing.SequenceParser(
9847 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1),
9848 new System.Text.Parsing.ExpectationParser(
9849 new System.Text.Parsing.NonterminalParser(ToUtf32("name"), ToUtf32("identifier"), 0))),
9850 new System.Text.Parsing.GroupingParser(
9851 new System.Text.Parsing.AlternativeParser(
9852 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9853 new System.Text.Parsing.CharParser(';')),
9854 new System.Text.Parsing.SequenceParser(
9855 new System.Text.Parsing.ExpectationParser(
9856 new System.Text.Parsing.CharParser('=')),
9857 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9858 new System.Text.Parsing.NonterminalParser(ToUtf32("Constant"), ToUtf32("Constant"), 1))))))));
9859 AddRule(new ConstantRule(ToUtf32("Constant"), GetScope(), Domain()->GetNextRuleId(),
9860 new System.Text.Parsing.AlternativeParser(
9861 new System.Text.Parsing.AlternativeParser(
9862 new System.Text.Parsing.AlternativeParser(
9863 new System.Text.Parsing.AlternativeParser(
9864 new System.Text.Parsing.AlternativeParser(
9865 new System.Text.Parsing.AlternativeParser(
9866 new System.Text.Parsing.AlternativeParser(
9867 new System.Text.Parsing.AlternativeParser(
9868 new System.Text.Parsing.AlternativeParser(
9869 new System.Text.Parsing.AlternativeParser(
9870 new System.Text.Parsing.AlternativeParser(
9871 new System.Text.Parsing.AlternativeParser(
9872 new System.Text.Parsing.AlternativeParser(
9873 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9874 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolConstant"), ToUtf32("BoolConstant"), 1)),
9875 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9876 new System.Text.Parsing.NonterminalParser(ToUtf32("SByteConstant"), ToUtf32("SByteConstant"), 1))),
9877 new System.Text.Parsing.ActionParser(ToUtf32("A2"),
9878 new System.Text.Parsing.NonterminalParser(ToUtf32("ByteConstant"), ToUtf32("ByteConstant"), 1))),
9879 new System.Text.Parsing.ActionParser(ToUtf32("A3"),
9880 new System.Text.Parsing.NonterminalParser(ToUtf32("ShortConstant"), ToUtf32("ShortConstant"), 1))),
9881 new System.Text.Parsing.ActionParser(ToUtf32("A4"),
9882 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortConstant"), ToUtf32("UShortConstant"), 1))),
9883 new System.Text.Parsing.ActionParser(ToUtf32("A5"),
9884 new System.Text.Parsing.NonterminalParser(ToUtf32("IntConstant"), ToUtf32("IntConstant"), 1))),
9885 new System.Text.Parsing.ActionParser(ToUtf32("A6"),
9886 new System.Text.Parsing.NonterminalParser(ToUtf32("UIntConstant"), ToUtf32("UIntConstant"), 1))),
9887 new System.Text.Parsing.ActionParser(ToUtf32("A7"),
9888 new System.Text.Parsing.NonterminalParser(ToUtf32("LongConstant"), ToUtf32("LongConstant"), 1))),
9889 new System.Text.Parsing.ActionParser(ToUtf32("A8"),
9890 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongConstant"), ToUtf32("ULongConstant"), 1))),
9891 new System.Text.Parsing.ActionParser(ToUtf32("A9"),
9892 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatConstant"), ToUtf32("FloatConstant"), 1))),
9893 new System.Text.Parsing.ActionParser(ToUtf32("A10"),
9894 new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleConstant"), ToUtf32("DoubleConstant"), 1))),
9895 new System.Text.Parsing.ActionParser(ToUtf32("A11"),
9896 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrConstant"), ToUtf32("PtrConstant"), 1))),
9897 new System.Text.Parsing.ActionParser(ToUtf32("A12"),
9898 new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayConstant"), ToUtf32("ArrayConstant"), 1))),
9899 new System.Text.Parsing.ActionParser(ToUtf32("A13"),
9900 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureConstant"), ToUtf32("StructureConstant"), 1)))));
9901 AddRule(new BoolConstantRule(ToUtf32("BoolConstant"), GetScope(), Domain()->GetNextRuleId(),
9902 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9903 new System.Text.Parsing.GroupingParser(
9904 new System.Text.Parsing.SequenceParser(
9905 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("BoolType"), 1),
9906 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("BoolValue"), 0))))));
9907 AddRule(new BoolValueRule(ToUtf32("BoolValue"), GetScope(), Domain()->GetNextRuleId(),
9908 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9909 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("bool"), 0))));
9910 AddRule(new SByteConstantRule(ToUtf32("SByteConstant"), GetScope(), Domain()->GetNextRuleId(),
9911 new System.Text.Parsing.SequenceParser(
9912 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("SByteType"), 1),
9913 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9914 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("SByteValue"), 0)))));
9915 AddRule(new SByteValueRule(ToUtf32("SByteValue"), GetScope(), Domain()->GetNextRuleId(),
9916 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9917 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("sbyte"), 0))));
9918 AddRule(new ByteConstantRule(ToUtf32("ByteConstant"), GetScope(), Domain()->GetNextRuleId(),
9919 new System.Text.Parsing.SequenceParser(
9920 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ByteType"), 1),
9921 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9922 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ByteValue"), 0)))));
9923 AddRule(new ByteValueRule(ToUtf32("ByteValue"), GetScope(), Domain()->GetNextRuleId(),
9924 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9925 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("byte"), 0))));
9926 AddRule(new ShortConstantRule(ToUtf32("ShortConstant"), GetScope(), Domain()->GetNextRuleId(),
9927 new System.Text.Parsing.SequenceParser(
9928 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ShortType"), 1),
9929 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9930 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ShortValue"), 0)))));
9931 AddRule(new ShortValueRule(ToUtf32("ShortValue"), GetScope(), Domain()->GetNextRuleId(),
9932 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9933 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("short"), 0))));
9934 AddRule(new UShortConstantRule(ToUtf32("UShortConstant"), GetScope(), Domain()->GetNextRuleId(),
9935 new System.Text.Parsing.SequenceParser(
9936 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UShortType"), 1),
9937 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9938 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UShortValue"), 0)))));
9939 AddRule(new UShortValueRule(ToUtf32("UShortValue"), GetScope(), Domain()->GetNextRuleId(),
9940 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9941 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ushort"), 0))));
9942 AddRule(new IntConstantRule(ToUtf32("IntConstant"), GetScope(), Domain()->GetNextRuleId(),
9943 new System.Text.Parsing.SequenceParser(
9944 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("IntType"), 1),
9945 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9946 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("IntValue"), 0)))));
9947 AddRule(new IntValueRule(ToUtf32("IntValue"), GetScope(), Domain()->GetNextRuleId(),
9948 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9949 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("int"), 0))));
9950 AddRule(new UIntConstantRule(ToUtf32("UIntConstant"), GetScope(), Domain()->GetNextRuleId(),
9951 new System.Text.Parsing.SequenceParser(
9952 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UIntType"), 1),
9953 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9954 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UIntValue"), 0)))));
9955 AddRule(new UIntValueRule(ToUtf32("UIntValue"), GetScope(), Domain()->GetNextRuleId(),
9956 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9957 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))));
9958 AddRule(new LongConstantRule(ToUtf32("LongConstant"), GetScope(), Domain()->GetNextRuleId(),
9959 new System.Text.Parsing.SequenceParser(
9960 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("LongType"), 1),
9961 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9962 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("LongValue"), 0)))));
9963 AddRule(new LongValueRule(ToUtf32("LongValue"), GetScope(), Domain()->GetNextRuleId(),
9964 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9965 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("long"), 0))));
9966 AddRule(new ULongConstantRule(ToUtf32("ULongConstant"), GetScope(), Domain()->GetNextRuleId(),
9967 new System.Text.Parsing.SequenceParser(
9968 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ULongType"), 1),
9969 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9970 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ULongValue"), 0)))));
9971 AddRule(new ULongValueRule(ToUtf32("ULongValue"), GetScope(), Domain()->GetNextRuleId(),
9972 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9973 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ulong"), 0))));
9974 AddRule(new FloatConstantRule(ToUtf32("FloatConstant"), GetScope(), Domain()->GetNextRuleId(),
9975 new System.Text.Parsing.SequenceParser(
9976 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("FloatType"), 1),
9977 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9978 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("FloatValue"), 0)))));
9979 AddRule(new FloatValueRule(ToUtf32("FloatValue"), GetScope(), Domain()->GetNextRuleId(),
9980 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9981 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("float"), 0))));
9982 AddRule(new DoubleConstantRule(ToUtf32("DoubleConstant"), GetScope(), Domain()->GetNextRuleId(),
9983 new System.Text.Parsing.SequenceParser(
9984 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("DoubleType"), 1),
9985 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9986 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("DoubleValue"), 0)))));
9987 AddRule(new DoubleValueRule(ToUtf32("DoubleValue"), GetScope(), Domain()->GetNextRuleId(),
9988 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9989 new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("double"), 0))));
9990 AddRule(new PtrConstantRule(ToUtf32("PtrConstant"), GetScope(), Domain()->GetNextRuleId(),
9991 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
9992 new System.Text.Parsing.GroupingParser(
9993 new System.Text.Parsing.SequenceParser(
9994 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
9995 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1)),
9996 new System.Text.Parsing.KeywordParser(ToUtf32("null")))))));
9997 AddRule(new ArrayConstantRule(ToUtf32("ArrayConstant"), GetScope(), Domain()->GetNextRuleId(),
9998 new System.Text.Parsing.SequenceParser(
9999 new System.Text.Parsing.SequenceParser(
10000 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10001 new System.Text.Parsing.CharParser('[')),
10002 new System.Text.Parsing.OptionalParser(
10003 new System.Text.Parsing.GroupingParser(
10004 new System.Text.Parsing.ListParser(
10005 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10006 new System.Text.Parsing.NonterminalParser(ToUtf32("element"), ToUtf32("Constant"), 1)),
10007 new System.Text.Parsing.CharParser(','))))),
10008 new System.Text.Parsing.CharParser(']'))));
10009 AddRule(new StructureConstantRule(ToUtf32("StructureConstant"), GetScope(), Domain()->GetNextRuleId(),
10010 new System.Text.Parsing.SequenceParser(
10011 new System.Text.Parsing.SequenceParser(
10012 new System.Text.Parsing.ActionParser(ToUtf32("A0"),
10013 new System.Text.Parsing.CharParser('{')),
10014 new System.Text.Parsing.OptionalParser(
10015 new System.Text.Parsing.GroupingParser(
10016 new System.Text.Parsing.ListParser(
10017 new System.Text.Parsing.ActionParser(ToUtf32("A1"),
10018 new System.Text.Parsing.NonterminalParser(ToUtf32("member"), ToUtf32("Constant"), 1)),
10019 new System.Text.Parsing.CharParser(','))))),
10020 new System.Text.Parsing.CharParser('}'))));
10021 SetSkipRuleName(ToUtf32("spaces"));
10022 }
10023 private List<ustring> keywords0;
10024 }
10025 }